QSS Solver GUI  4.5.3
mmomegui.cpp
Go to the documentation of this file.
1 /*****************************************************************************
2 
3  This file is part of QSS Solver.
4 
5  QSS Solver is free software: you can redistribute it and/or modify
6  it under the terms of the GNU General Public License as published by
7  the Free Software Foundation, either version 3 of the License, or
8  (at your option) any later version.
9 
10  QSS Solver is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  GNU General Public License for more details.
14 
15  You should have received a copy of the GNU General Public License
16  along with QSS Solver. If not, see <http://www.gnu.org/licenses/>.
17 
18  ******************************************************************************/
19 
20 #include <sys/types.h>
21 #include <signal.h>
22 
23 #include <QMdiSubWindow>
24 #include <QFileDialog>
25 #include <QMessageBox>
26 #include <Qt>
27 
28 #include <mmomegui.hpp>
29 #include <editor.hpp>
30 #include <treemodel.hpp>
31 #include <utils.hpp>
32 #include <comboboxdelegate.hpp>
33 #include <runform.hpp>
34 #include <settings.hpp>
35 
36 #include <qtermwidget5/qtermwidget.h>
37 
38 #define SLASH '/'
39 
40 MmomeGui *mainWindow;
41 
42 static const QString INIT_PYTHON =
43  "pip install libconf\n"
44  "python3\n"
45  "import os\n"
46  "import sys\n"
47  "MMOC_SRC = os.environ['MMOC_SRC']\n"
48  "sys.path.append(MMOC_SRC+'/python')\n"
49  "sys.path.append(MMOC_SRC+'/python/qss_solver')\n"
50  "import qss_solver\n"
51  "import qss_solver.results as solver_results\n"
52  "import qss_solver.model as solver_model\n"
53  "import qss_solver.simulate as solver_sim\n"
54  "c = os.system(\'clear\')\n";
55 
56 MmomeGui::MmomeGui() : QMainWindow(), _sbmlFile()
57 {
58  setupUi(this);
59  initialize();
60 }
61 
62 MmomeGui::~MmomeGui()
63 {
64  QByteArray new_geometry = saveGeometry();
65  QByteArray new_state = saveState(0);
66  QSettings settings;
67  settings.setValue("main_window_geometry", new_geometry);
68  settings.setValue("main_window_state", new_state);
69  Editor::drop();
70 }
71 
72 void MmomeGui::initialize()
73 {
74  _iniFile = "/qss-solver.ini";
75  _proc = nullptr;
76  _plot = nullptr;
77  _log = nullptr;
78  _sim_progress->setVisible(false);
79  QStringList headers;
80  headers << tr("File") << tr("Variable") << tr("Settings");
81 
82  _cboxd = new ComboBoxDelegate(_model_variables);
83  _model = new TreeModel(headers, this);
84  _utils = new Utils();
85  _compiler_msg->setTextColor(Qt::black);
86  _compiler_msg->setReadOnly(true);
87  setWindowState(Qt::WindowMaximized);
88 
89  createActions();
90  addToolBarItems();
91  addMenuBarItems();
92  enableActions(true);
93 
94  _settings_only = false;
95  _runDlg = new RunDlg(this);
96  connect(_runDlg, &RunDlg::accepted, this, &MmomeGui::runDlgClose);
97  connect(_runDlg, &RunDlg::rejected, this, &MmomeGui::runDlgRejected);
98 
99  _python_console = new QTermWidget();
100  _python_console->setScrollBarPosition(QTermWidget::ScrollBarRight);
101  _python_console->setColorScheme("Linux");
102  _python_console->sendText(INIT_PYTHON);
103  _py_console_widget->setWidget(_python_console);
104 
105  _console = new QTermWidget();
106  _console->setScrollBarPosition(QTermWidget::ScrollBarRight);
107  _console->setColorScheme("Linux");
108  _console_widget->setWidget(_console);
109 
110  QSettings settings;
111  const auto geometry = settings.value("main_window_geometry").toByteArray();
112  const auto state = settings.value("main_window_state").toByteArray();
113 
114  restoreGeometry(geometry);
115  restoreState(state);
116  updateGeometry();
117 }
118 
119 void MmomeGui::enableActions(bool f)
120 {
121  action_New->setEnabled(f);
122  action_Load->setEnabled(f);
123  actionImport->setEnabled(f);
124  action_Save->setEnabled(f);
125  action_Save_As->setEnabled(f);
126  actionSa_ve_All->setEnabled(f);
127  actionRun->setEnabled(f);
128  actionRun_2->setEnabled(f);
129  actionSettings->setEnabled(f);
130  actionCompile->setEnabled(!f);
131  actionDebug->setEnabled(f);
132  actionLog->setEnabled(f);
133  actionGraphics->setEnabled(f);
134  actionClear_Log->setEnabled(f);
135  actionMicroModelica_Language_Scpefication->setEnabled(f);
136  return;
137 }
138 void MmomeGui::addToolBarItems()
139 {
140  _model_toolbar->addAction(action_New);
141  _model_toolbar->addAction(action_Load);
142  _model_toolbar->addAction(actionImport);
143  _model_toolbar->addSeparator();
144  _model_toolbar->addAction(action_Save);
145  _model_toolbar->addAction(action_Save_As);
146  _model_toolbar->addAction(actionSa_ve_All);
147  _model_toolbar->addAction(actionSettings);
148  _model_toolbar->addSeparator();
149  _model_toolbar->addAction(actionRun);
150  _model_toolbar->addAction(actionRun_2);
151  _model_toolbar->addAction(actionCompile);
152  _model_toolbar->addAction(actionDebug);
153  _model_toolbar->addSeparator();
154  _model_toolbar->addAction(actionLog);
155  _model_toolbar->addAction(actionGraphics);
156  _model_toolbar->addAction(actionClear_Log);
157 }
158 
159 void MmomeGui::addMenuBarItems()
160 {
161  menu_View->addAction(_model_plot->toggleViewAction());
162  menu_View->addAction(_model_messages->toggleViewAction());
163 }
164 
165 void MmomeGui::done(QString name, QString ext)
166 {
167  QMdiSubWindow *sw = mdiArea->currentSubWindow();
168  if (sw) {
169  if (!ext.endsWith(".log")) deleteVariables(name);
170  if (Editor::instance()->count() == 0) {
171  Editor::drop();
172  sw->close();
173  _model_variables->setModel(NULL);
174  delete sw;
175  }
176  }
177 }
178 
179 void MmomeGui::closeEvent(QCloseEvent *event)
180 {
181  QMdiSubWindow *sw = mdiArea->currentSubWindow();
182  if (sw) {
183  Editor::instance()->closeFiles();
184  }
185  Editor::drop();
186  event->accept();
187 }
188 
189 void MmomeGui::on_action_Save_As_triggered()
190 {
191  QMdiSubWindow const *sw = mdiArea->currentSubWindow();
192  if (sw) {
193  Editor::instance()->saveAs(Editor::instance()->newFileName());
194  }
195 }
196 
197 void MmomeGui::on_actionSettings_triggered()
198 {
199  _settingsDlg = new SettingsDlg(this);
200  connect(_settingsDlg, &SettingsDlg::finished, this, &MmomeGui::settingsDlgClosed);
201  enableActions(false);
202  _settingsDlg->show();
203 }
204 
205 void MmomeGui::on_actionImport_triggered()
206 {
207  QString fileName = QFileDialog::getOpenFileName(this, tr("Load SBML Model"), _utils->appDir(MMOC_MODELS), "XML *.xml (*.xml)");
208  if (fileName.isNull()) {
209  return;
210  }
211  QFileInfo sbmlfi(fileName);
212  QDir modelsDir(_utils->appDir(MMOC_MODELS));
213  modelsDir.mkdir(sbmlfi.baseName());
214  modelsDir.cd(sbmlfi.baseName());
215  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\nImport SBML model: ") + fileName);
216  _proc = new QProcess(this);
217  connect(_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished), this, &MmomeGui::importFinished);
218  _sbmlFile = modelsDir.absolutePath() + SLASH + sbmlfi.baseName() + ".mo";
219  QStringList args;
220  args << "-o " + _sbmlFile;
221  args << fileName;
222  QString sim = _utils->appCommand(CMD_SBML);
223  QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
224  env.insert("MMOC_LIBS", QDir(_utils->appDir(MMOC_LIBS)).absolutePath()); // Add an environment variable
225  _proc->setProcessEnvironment(env);
226  _proc->start(_utils->appDir(MMOC_BIN) + QString(SLASH) + sim, args);
227  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + "\n" + _utils->appDir(MMOC_BIN) + SLASH + sim + " " + _sbmlFile + " " +
228  fileName);
229 }
230 
231 void MmomeGui::on_action_New_triggered() { editModel(QString()); }
232 
233 void MmomeGui::editModel(QString name)
234 {
235  QMdiSubWindow *sw = mdiArea->currentSubWindow();
236  if (sw) {
237  Editor::instance()->editModel(name);
238  } else {
239  QMdiSubWindow *sw = new QMdiSubWindow(this, Qt::CustomizeWindowHint);
240  sw->setWidget(Editor::instance(this, name));
241  mdiArea->addSubWindow(sw);
242  connect(Editor::instance(), &ModelEditor::done, this, &MmomeGui::done);
243  connect(Editor::instance(), &ModelEditor::clean, this, &MmomeGui::cleanBuildDir);
244  connect(action_Save, &QAction::triggered, this, []() { Editor::instance()->save(); });
245  connect(actionSa_ve_All, &QAction::triggered, Editor::instance(), &ModelEditor::saveAll);
246  Editor::instance()->setWindowState(Qt::WindowMaximized);
247  Editor::instance()->show();
248  }
249 }
250 
251 void MmomeGui::on_action_Load_triggered()
252 {
253  QString fileName = QFileDialog::getOpenFileName(this, tr("Load Model"), _utils->appDir(MMOC_MODELS), "MicroModelica *.mo (*.mo)");
254  if (fileName.isNull()) {
255  return;
256  }
257  loadFile(fileName);
258 }
259 
260 void MmomeGui::on_actionDebug_triggered()
261 {
262  if (Editor::instance()->activeBaseFileName().isEmpty()) return;
263  _compiler_msg->clear();
264  enableActions(false);
265  compile(true);
266 }
267 
268 void MmomeGui::on_actionMicroModelica_Language_Scpefication_triggered()
269 {
270  QString link = "http://www.fceia.unr.edu.ar/control/modelica/micromodelicaspec.pdf";
271  QDesktopServices::openUrl(QUrl(link));
272 }
273 
274 void MmomeGui::on_actionQSS_Solver_Engine_Documentation_triggered()
275 {
276  QString link = "http://www.cifasis-conicet.gov.ar/jfernandez/engine/";
277  QDesktopServices::openUrl(QUrl(link));
278 }
279 
280 void MmomeGui::on_actionMicroModelica_Compiler_Documentation_triggered()
281 {
282  QString link = "http://www.cifasis-conicet.gov.ar/jfernandez/mmoc/";
283  QDesktopServices::openUrl(QUrl(link));
284 }
285 
286 void MmomeGui::on_actionSBML_Translator_Documentation_triggered()
287 {
288  QString link = "http://www.cifasis-conicet.gov.ar/jfernandez/sbml/";
289  QDesktopServices::openUrl(QUrl(link));
290 }
291 
292 void MmomeGui::run_finished(int exitCode, QProcess::ExitStatus exitStatus)
293 {
294  if (exitStatus == QProcess::NormalExit && exitCode == 0) {
295  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\n") + _proc->readAllStandardError());
296  QByteArray logs = _proc->readAllStandardOutput();
297  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\n") + logs);
298  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("Simulation ended."));
299  QDir buildDir(_utils->appDir(MMOC_BUILD));
300  buildDir.refresh();
301  QString _name = Editor::instance()->activeBaseFileName();
302  deleteVariables(_name);
303  addVariables();
304  selectVariables();
305  } else {
306  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\n") + _proc->readAllStandardError());
307  QByteArray logs = _proc->readAllStandardOutput();
308  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\n") + logs);
309  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + "Simulation failed. Exit code: " + QString::number(exitCode));
310  }
311  delete _proc;
312  _proc = NULL;
313  _compiler_msg->moveCursor(QTextCursor::End);
314  _compiler_msg->ensureCursorVisible();
315  enableActions(true);
316  _sim_progress->setVisible(false);
317  _settings_only = false;
318 }
319 
320 void MmomeGui::settingsDlgClosed() { enableActions(true); }
321 
322 void MmomeGui::run(QString name)
323 {
324  QDir outputDir(_utils->appDir(MMOC_OUTPUT));
325  outputDir.mkdir(Editor::instance()->activeBaseFileName());
326  outputDir.cd(Editor::instance()->activeBaseFileName());
327  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\nCreating/cleaning directory: ") + outputDir.absolutePath());
328  on_actionClear_Log_triggered();
329  _proc = new QProcess(this);
330  connect(_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished), this, &MmomeGui::run_finished);
331  QStringList args;
332  args << name;
333  if (Editor::instance()->isParallel()) {
334  args << QString("true");
335  QFileInfo _mo_file(Editor::instance()->activeFullFileName());
336  args << _mo_file.absolutePath();
337  } else {
338  args << QString("false");
339  }
340  if (Editor::instance()->semiStaticPartitioning()) {
341  args << QString("true");
342  } else {
343  args << QString("false");
344  }
345  connect(_proc, &QProcess::readyReadStandardError, this, &MmomeGui::simulation_message);
346  _timeInterval = Editor::instance()->stopTime().toDouble() - Editor::instance()->startTime().toDouble();
347  _sim_progress->setMaximum(100);
348  _sim_progress->reset();
349  _sim_progress->setVisible(true);
350  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\nStarting simulation.\n"));
351  _compiler_msg->moveCursor(QTextCursor::End);
352  _compiler_msg->ensureCursorVisible();
353  QString sim = _utils->appCommand(CMD_SIMULATE);
354  QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
355  env.insert("MMOC_BUILD", QDir(_utils->appDir(MMOC_BUILD)).absolutePath());
356  env.insert("MMOC_BIN", QDir(_utils->appDir(MMOC_BIN)).absolutePath());
357  env.insert("MMOC_ENGINE", QDir(_utils->appDir(MMOC_ENGINE)).absolutePath());
358  env.insert("MMOC_LIBS", QDir(_utils->appDir(MMOC_LIBS)).absolutePath());
359  env.insert("MMOC_MODELS", QDir(_utils->appDir(MMOC_MODELS)).absolutePath());
360  env.insert("MMOC_SRC", QDir(_utils->appDir(MMOC_SOURCE)).absolutePath());
361  env.insert("MMOC_PACKAGES", QDir(_utils->appDir(MMOC_PACKAGES)).absolutePath());
362  env.insert("MMOC_LIBRARIES", QDir(_utils->appDir(MMOC_LIBRARIES)).absolutePath());
363  env.insert("MMOC_INCLUDE", QDir(_utils->appDir(MMOC_INCLUDE)).absolutePath());
364  env.insert("MMOC_OUTPUT", QDir(_utils->appDir(MMOC_OUTPUT)).absolutePath());
365  env.insert("LD_LIBRARY_PATH", QDir(_utils->appDir(MMOC_LIBRARIES)).absolutePath() + "/../lib");
366  _proc->setProcessEnvironment(env);
367  _proc->start(_utils->appDir(MMOC_BIN) + SLASH + sim, args);
368 }
369 
370 void MmomeGui::simulation_message()
371 {
372  QString out(_proc->readAllStandardError().constData());
373  int _init = out.lastIndexOf('*');
374  if (_init >= 0) {
375  int pc = (out.mid(_init + 1).toDouble() / _timeInterval) * 100.0;
376  _sim_progress->setValue(pc);
377  }
378 }
379 
380 void MmomeGui::runDlgRejected() { _settings_only = false; }
381 
382 void MmomeGui::runDlgClose()
383 {
384  Editor::instance()->setStartTime(_runDlg->startTime());
385  Editor::instance()->setStopTime(_runDlg->stopTime());
386  Editor::instance()->setTolerance(_runDlg->tolerance());
387  Editor::instance()->setAbsTolerance(_runDlg->absTolerance());
388  Editor::instance()->setSolver(_runDlg->solver());
389  Editor::instance()->setScheduler(_runDlg->scheduler());
390  Editor::instance()->setOutput(_runDlg->output());
391  Editor::instance()->setOutputType(_runDlg->outputType());
392  Editor::instance()->setPeriod(_runDlg->period());
393  Editor::instance()->setSymDiff(_runDlg->symDiff());
394  Editor::instance()->setZcHyst(_runDlg->zcHyst());
395  Editor::instance()->setDerDelta(_runDlg->derDelta());
396  Editor::instance()->setMinStep(_runDlg->minStep());
397  Editor::instance()->setParallel(_runDlg->parallel());
398  Editor::instance()->setLPS(_runDlg->LPS());
399  Editor::instance()->setDT(_runDlg->DT());
400  Editor::instance()->setDtSynch(_runDlg->dtSynch());
401  Editor::instance()->setJacobian(_runDlg->jacobian());
402  Editor::instance()->setPartitionMethod(_runDlg->partitionMethod());
403  Editor::instance()->setPatohSettings(_runDlg->patohSettings());
404  Editor::instance()->setScotchSettings(_runDlg->scotchSettings());
405  Editor::instance()->setMetisSettings(_runDlg->metisSettings());
406  Editor::instance()->setGenerateArch(_runDlg->generateArch());
407  Editor::instance()->setDebugGraph(_runDlg->debugGraph());
408  Editor::instance()->setReorderPartition(_runDlg->reorderPartition());
409  Editor::instance()->setImbalance(_runDlg->imbalance());
410  Editor::instance()->setBDFPart(_runDlg->BDFPart());
411  Editor::instance()->setBDFPartitionDepth(_runDlg->BDFPartitionDepth());
412  Editor::instance()->setBDFMaxStep(_runDlg->BDFMaxStep());
413  Editor::instance()->setSemiStaticPartitioning(_runDlg->semiStaticPartitioning());
414  Editor::instance()->setDescription(_runDlg->description());
415  Editor::instance()->writeAnnotations();
416  bool debugFlag = _runDlg->enableDebug();
417  enableActions(false);
418  if (Editor::instance()->activeDirty()) {
419  Editor::instance()->save();
420  compile(debugFlag);
421  } else {
422  QDir buildDir(_utils->appDir(MMOC_BUILD));
423  buildDir.cd(Editor::instance()->activeBaseFileName());
424  QFileInfo exefi(buildDir.absolutePath() + SLASH + Editor::instance()->activeBaseFileName());
425  if (!exefi.exists()) {
426  enableActions(false);
427  _settings_only = false;
428  }
429  compile(debugFlag);
430  }
431 }
432 
433 void MmomeGui::on_actionRun_2_triggered()
434 {
435  _settings_only = true;
436  on_actionRun_triggered();
437 }
438 
439 void MmomeGui::on_actionRun_triggered()
440 {
441  if (Editor::instance()->activeBaseFileName().isEmpty()) {
442  return;
443  }
444  if (!Editor::instance()->checkModel()) {
445  QMessageBox::information(this, "Simulation", "No model definition found.");
446  return;
447  }
448  _compiler_msg->clear();
449  _runDlg->setStartTime(Editor::instance()->startTime());
450  _runDlg->setStopTime(Editor::instance()->stopTime());
451  _runDlg->setTolerance(Editor::instance()->tolerance());
452  _runDlg->setAbsTolerance(Editor::instance()->absTolerance());
453  _runDlg->setSolver(Editor::instance()->solver());
454  _runDlg->setScheduler(Editor::instance()->scheduler());
455  _runDlg->setOutput(Editor::instance()->output());
456  _runDlg->setOutputType(Editor::instance()->outputType());
457  _runDlg->setPeriod(Editor::instance()->period());
458  _runDlg->setSymDiff(Editor::instance()->symDiff());
459  _runDlg->setZcHyst(Editor::instance()->zcHyst());
460  _runDlg->setDerDelta(Editor::instance()->derDelta());
461  _runDlg->setMinStep(Editor::instance()->minStep());
462  _runDlg->setParallel(Editor::instance()->parallel());
463  _runDlg->setLPS(Editor::instance()->LPS());
464  _runDlg->setDT(Editor::instance()->DT());
465  _runDlg->setPartitionMethod(Editor::instance()->partitionMethod());
466  _runDlg->setPatohSettings(Editor::instance()->patohSettings());
467  _runDlg->setScotchSettings(Editor::instance()->scotchSettings());
468  _runDlg->setMetisSettings(Editor::instance()->metisSettings());
469  _runDlg->setGenerateArch(Editor::instance()->generateArch());
470  _runDlg->setReorderPartition(Editor::instance()->reorderPartition());
471  _runDlg->setDebugGraph(Editor::instance()->debugGraph());
472  _runDlg->setImbalance(Editor::instance()->imbalance());
473  _runDlg->setBDFPart(Editor::instance()->BDFPart());
474  _runDlg->setBDFPartitionDepth(Editor::instance()->BDFPartitionDepth());
475  _runDlg->setBDFMaxStep(Editor::instance()->BDFMaxStep());
476  _runDlg->setSemiStaticPartitioning(Editor::instance()->semiStaticPartitioning());
477  _runDlg->setDtSynch(Editor::instance()->dtSynch());
478  _runDlg->setDescription(Editor::instance()->description());
479  _runDlg->setJacobian(Editor::instance()->jacobian());
480  _runDlg->show();
481 }
482 
483 bool MmomeGui::plotScript()
484 {
485  QString name = Editor::instance()->activeBaseFileName();
486  QFile file(_utils->appDir(MMOC_OUTPUT) + SLASH + name + SLASH + name + QString(".plt"));
487  bool ret = false;
488  if (!file.open(QIODevice::ReadWrite | QIODevice::Truncate)) {
489  QMessageBox::critical(this, QString(tr("Error")), QString(tr("Can't open file ")) + name + QString(".plt"));
490  file.close();
491  return false;
492  }
493  QString _data;
494  _data.append("set title \"").append(name).append("\"\n");
495  _data.append("set ylabel \"State Variables\"\n");
496  _data.append("set xlabel \"Time\"\n");
497  QString buff;
498  buff.append("set xrange [0:").append(Editor::instance()->stopTime()).append("]\n");
499  _data.append(buff);
500  _data.append("set grid\n");
501  _data.append("plot ");
502  for (int k = 0; k < _model->rowCount(); k++) {
503  QStandardItem *it = _model->item(k);
504  for (int g = 0; g < it->rowCount(); g++) {
505  QStandardItem *c = it->child(g, 1);
506  QString name = c->text();
507  if (c->checkState() == Qt::Checked) {
508  _data.append("\"")
509  .append(_utils->appDir(MMOC_OUTPUT))
510  .append(SLASH)
511  .append(_model->item(k)->text())
512  .append(SLASH)
513  .append(c->text())
514  .append(".dat\"");
515  c = it->child(g, 2);
516  if (c->text() != "None") {
517  _data.append(" with ").append(c->text());
518  }
519  _data.append(" title \"").append(name).append("\"");
520  _data.append(", ");
521  ret = true;
522  }
523  }
524  }
525  int l = _data.length();
526  _data = _data.remove(l - 2, 1);
527  _data.append("\n");
528  if (file.write(_data.toStdString().c_str()) == -1) {
529  QMessageBox::critical(this, QString(tr("Error")), QString(tr("Can't write data ")) + name + QString(".plt"));
530  file.close();
531  return false;
532  }
533  if (!file.flush()) {
534  QMessageBox::critical(this, QString(tr("Error")), QString(tr("Can't save file ")) + name + QString(".plt"));
535  file.close();
536  return false;
537  }
538  return ret;
539 }
540 
541 void MmomeGui::cleanBuildDir(int idx)
542 {
543  if (_settings_only) return;
544  QDir buildDir(_utils->appDir(MMOC_BUILD));
545  buildDir.mkdir(Editor::instance()->baseFileName(idx));
546  buildDir.cd(Editor::instance()->baseFileName(idx));
547  QFileInfo makefi(buildDir.absolutePath() + SLASH + Editor::instance()->baseFileName(idx) + QString(".makefile"));
548  QFileInfo cfi(buildDir.absolutePath() + SLASH + Editor::instance()->baseFileName(idx) + QString(".c"));
549  QFileInfo exefi(buildDir.absolutePath() + SLASH + Editor::instance()->activeBaseFileName());
550  if (makefi.exists()) {
551  buildDir.remove(makefi.absoluteFilePath());
552  }
553  if (cfi.exists()) {
554  buildDir.remove(cfi.absoluteFilePath());
555  }
556  if (exefi.exists()) {
557  buildDir.remove(exefi.absoluteFilePath());
558  }
559  setCurrentFile(Editor::instance()->activeFullFileName());
560 }
561 
562 bool MmomeGui::compile(bool dbg)
563 {
564  _compiler_msg->clear();
565  QFileInfo modelFile(Editor::instance()->activeFullFileName());
566  QDir buildDir(_utils->appDir(MMOC_BUILD));
567  buildDir.mkdir(Editor::instance()->activeBaseFileName());
568  buildDir.cd(Editor::instance()->activeBaseFileName());
569  QString fileName(buildDir.absolutePath() + SLASH + Editor::instance()->activeBaseFileName() + QString(".part"));
570  if (QFile::exists(fileName)) {
571  QFile::remove(fileName);
572  }
573  QFile::copy(modelFile.absoluteDir().absolutePath() + SLASH + Editor::instance()->activeBaseFileName() + QString(".part"), fileName);
574  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + buildDir.absolutePath());
575  QFileInfo makefi(buildDir.absolutePath() + SLASH + Editor::instance()->activeBaseFileName() + QString(".makefile"));
576  QFileInfo cfi(buildDir.absolutePath() + SLASH + Editor::instance()->activeBaseFileName() + QString(".c"));
577  if (!_settings_only) {
578  cleanBuildDir(Editor::instance()->activeFileIndex());
579  }
580  QString flags = _utils->appFlag(FLG_FLAGS);
581  _proc = new QProcess(this);
582  connect(_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished), this, &MmomeGui::comp_finished);
583  QStringList args;
584  QString set;
585  if (_settings_only) {
586  set += "-s ";
587  }
588  if (!flags.isEmpty()) {
589  set += flags + " ";
590  }
591  if (dbg) {
592  flags = _utils->appFlag(FLG_DEBUG);
593  if (flags.isEmpty()) {
594  QMessageBox::warning(this, "Debug Flags", "Debug mode enabled but no debug flags found. They can be set from \"File->Settings\"");
595  }
596  flags.append(" ");
597  set += flags;
598  }
599  set += "-o " + buildDir.absolutePath() + SLASH + Editor::instance()->activeBaseFileName();
600  args << set;
601  args << Editor::instance()->activeFullFileName();
602  QString comp = _utils->appCommand(CMD_COMPILE);
603  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\nCompiling model: "));
604  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\n") + _utils->appDir(MMOC_BIN) + SLASH + comp + " " + set + " " +
605  Editor::instance()->activeFullFileName());
606  _compiler_msg->moveCursor(QTextCursor::End);
607  _compiler_msg->ensureCursorVisible();
608  QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
609  env.insert("MMOC_BUILD", QDir(_utils->appDir(MMOC_BUILD)).absolutePath());
610  env.insert("MMOC_BIN", QDir(_utils->appDir(MMOC_BIN)).absolutePath());
611  env.insert("MMOC_ENGINE", QDir(_utils->appDir(MMOC_ENGINE)).absolutePath());
612  env.insert("MMOC_LIBS", QDir(_utils->appDir(MMOC_LIBS)).absolutePath());
613  env.insert("MMOC_MODELS", QDir(_utils->appDir(MMOC_MODELS)).absolutePath());
614  env.insert("MMOC_SRC", QDir(_utils->appDir(MMOC_SOURCE)).absolutePath());
615  env.insert("MMOC_PACKAGES", QDir(_utils->appDir(MMOC_PACKAGES)).absolutePath());
616  env.insert("MMOC_LIBRARIES", QDir(_utils->appDir(MMOC_LIBRARIES)).absolutePath());
617  env.insert("MMOC_INCLUDE", QDir(_utils->appDir(MMOC_INCLUDE)).absolutePath());
618  env.insert("MMOC_OUTPUT", QDir(_utils->appDir(MMOC_OUTPUT)).absolutePath());
619  _proc->setProcessEnvironment(env);
620  _proc->start(_utils->appDir(MMOC_BIN) + SLASH + comp, args);
621  return true;
622 }
623 
624 void MmomeGui::importFinished(int exitCode, QProcess::ExitStatus exitStatus)
625 {
626  if (exitStatus == QProcess::NormalExit) {
627  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\n") + _proc->readAllStandardError());
628  editModel(_sbmlFile);
629  addVariables();
630  } else {
631  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\nCan not import SBML file.") + QString::number(exitCode));
632  }
633  _sbmlFile.clear();
634  delete _proc;
635  _proc = NULL;
636 }
637 
638 void MmomeGui::make_finished(int exitCode, QProcess::ExitStatus exitStatus)
639 {
640  if (exitStatus == QProcess::NormalExit) {
641  QString execName = _utils->appDir(MMOC_BUILD) + SLASH + Editor::instance()->activeBaseFileName() + QString(SLASH) +
642  Editor::instance()->activeBaseFileName();
643 #ifdef _WIN32
644  execName += ".exe";
645 #endif
646  QFileInfo exefi(execName);
647  if (!exefi.exists()) {
648  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\n") + _proc->readAllStandardError());
649  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\nCan't generate binary file.") + QString::number(exitCode));
650  enableActions(true);
651  _settings_only = false;
652  return;
653  } else {
654  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\nBinary file generated, ready to start simulation."));
655  }
656  } else {
657  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\nError generating binary file.).") + QString::number(exitCode));
658  enableActions(true);
659  _settings_only = false;
660  return;
661  }
662  delete _proc;
663  _proc = nullptr;
664  _compiler_msg->moveCursor(QTextCursor::End);
665  _compiler_msg->ensureCursorVisible();
666  run(Editor::instance()->activeBaseFileName());
667 }
668 
669 void MmomeGui::comp_finished(int exitCode, QProcess::ExitStatus exitStatus)
670 {
671  if (exitStatus == QProcess::NormalExit) {
672  QDir buildDir(_utils->appDir(MMOC_BUILD));
673  buildDir.mkdir(Editor::instance()->activeBaseFileName());
674  buildDir.cd(Editor::instance()->activeBaseFileName());
675  QFileInfo cfi(buildDir.absolutePath() + SLASH + Editor::instance()->activeBaseFileName() + QString(".c"));
676  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\n") + _proc->readAllStandardError());
677  QByteArray logs = _proc->readAllStandardOutput();
678  if (!logs.isEmpty()) _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\n") + logs);
679  if (!cfi.exists()) {
680  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\nCan't generate C file."));
681  enableActions(true);
682  _settings_only = false;
683  return;
684  }
685  QFileInfo modelfi = Editor::instance()->activeFullFileName();
686  QDir modeldir = modelfi.absoluteDir();
687  QFileInfoList filst = modeldir.entryInfoList(QStringList() << "*.c"
688  << "*.h");
689  foreach (QFileInfo qfi, filst) {
690  QFile file(qfi.filePath());
691  file.copy(buildDir.absolutePath() + SLASH + qfi.fileName());
692  file.close();
693  }
694  modeldir = QCoreApplication::applicationDirPath();
695  filst = modeldir.entryInfoList(QStringList() << "*.im");
696  foreach (QFileInfo qfi, filst) {
697  QFile file(qfi.filePath());
698  file.copy(buildDir.absolutePath() + SLASH + qfi.fileName());
699  file.remove();
700  }
701  QFileInfo makefi(buildDir.absolutePath() + SLASH + Editor::instance()->activeBaseFileName() + QString(".makefile"));
702  if (!makefi.exists()) {
703  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\nCan't generate makefile."));
704  enableActions(true);
705  _settings_only = false;
706  return;
707  }
708  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\nRunning makefile."));
709  QStringList args;
710  args.clear();
711  args << makefi.baseName();
712  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\n") + QString("make -f ") + buildDir.absolutePath() + SLASH +
713  makefi.fileName());
714  QString build = _utils->appCommand(CMD_BUILD);
715  delete _proc;
716  _proc = new QProcess(this);
717  connect(_proc, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished), this, &MmomeGui::make_finished);
718  QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
719  env.insert("MMOC_BUILD", QDir(_utils->appDir(MMOC_BUILD)).absolutePath());
720  env.insert("MMOC_BIN", QDir(_utils->appDir(MMOC_BIN)).absolutePath());
721  _proc->setProcessEnvironment(env);
722  _proc->start(_utils->appDir(MMOC_BIN) + SLASH + build, args);
723  } else {
724  delete _proc;
725  _proc = nullptr;
726  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\nError during compilation.") + QString::number(exitCode));
727  enableActions(true);
728  _settings_only = false;
729  }
730  _compiler_msg->moveCursor(QTextCursor::End);
731  _compiler_msg->ensureCursorVisible();
732 }
733 
734 void MmomeGui::on_actionCompile_triggered()
735 {
736  if (Editor::instance()->activeBaseFileName().isEmpty()) {
737  return;
738  }
739 
740 #ifdef Q_OS_LINUX
741  Q_PID pid = _proc->pid();
742  QProcess killer;
743  QStringList params;
744  params << "--ppid";
745  params << QString::number(pid);
746  params << "-o";
747  params << "pid";
748  params << "--noheaders";
749  killer.start("/bin/ps", params, QIODevice::ReadOnly);
750  if (killer.waitForStarted(-1)) {
751  if (killer.waitForFinished(-1)) {
752  QByteArray temp = killer.readAllStandardOutput();
753  QString str = QString::fromLocal8Bit(temp);
754  QStringList list = str.split("\n");
755 
756  for (int i = 0; i < list.size(); i++) {
757  if (!list.at(i).isEmpty()) ::kill(list.at(i).toInt(), SIGKILL);
758  }
759  }
760  }
761 #endif
762  _proc->kill();
763  enableActions(true);
764 }
765 
766 void MmomeGui::on_actionLog_triggered()
767 {
768  QString name = Editor::instance()->activeBaseFileName();
769  if (name.isEmpty()) {
770  return;
771  }
772  QString logCmd = _utils->appCommand(CMD_LOG);
773  _log = new QProcess(this);
774  connect(_log, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished), this, &MmomeGui::log_finished);
775  QStringList args;
776  args << name;
777  QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
778  env.insert("MMOC_OUTPUT", QDir(_utils->appDir(MMOC_OUTPUT)).absolutePath());
779  env.insert("MMOC_BIN", QDir(_utils->appDir(MMOC_BIN)).absolutePath());
780  _log->setProcessEnvironment(env);
781  _log->start(_utils->appDir(MMOC_BIN) + SLASH + logCmd, args);
782 }
783 
784 void MmomeGui::on_actionClear_Log_triggered()
785 {
786  QDir outputDir(_utils->appDir(MMOC_OUTPUT));
787  outputDir.mkdir(Editor::instance()->activeBaseFileName());
788  outputDir.cd(Editor::instance()->activeBaseFileName());
789  QStringList dirs = outputDir.entryList(QStringList() << "*.log"
790  << "*.dat"
791  << "*.plt");
792  foreach (QString f, dirs) {
793  outputDir.remove(f);
794  }
795 }
796 
797 void MmomeGui::on_actionClear_Messages_triggered() { _compiler_msg->clear(); }
798 
799 void MmomeGui::deleteVariables(QString name)
800 {
801  int idx = -1;
802  for (int k = 0; k < _model->rowCount(); k++) {
803  QStandardItem *it = _model->item(k);
804  if (name == it->text()) {
805  idx = k;
806  break;
807  }
808  }
809  if (idx < 0) return;
810  _model->removeRows(idx, 1);
811  _model_variables->setModel(_model);
812  _model_variables->setItemDelegateForColumn(2, _cboxd);
813  for (int column = 0; column < _model->columnCount(); ++column) {
814  _model_variables->resizeColumnToContents(column);
815  }
816 }
817 
818 void MmomeGui::createActions()
819 {
820  for (int i = 0; i < MaxRecentFiles; ++i) {
821  recentFileActs[i] = new QAction(this);
822  recentFileActs[i]->setVisible(false);
823  connect(recentFileActs[i], &QAction::triggered, this, &MmomeGui::openRecentFiles);
824  }
825  exitAct = new QAction(tr("E&xit"), this);
826  exitAct->setShortcuts(QKeySequence::Quit);
827  exitAct->setStatusTip(tr("Exit the application"));
828  connect(exitAct, &QAction::triggered, qApp, &QApplication::quit);
829  separatorAct = menu_File->addSeparator();
830  for (int i = 0; i < MaxRecentFiles; ++i) menu_File->addAction(recentFileActs[i]);
831  separatorAct->setVisible(false);
832  menu_File->addSeparator();
833  menu_File->addAction(exitAct);
834  updateRecentFileActions();
835 }
836 
837 void MmomeGui::openRecentFiles()
838 {
839  QAction *action = qobject_cast<QAction *>(sender());
840  if (action) {
841  loadFile(action->data().toString());
842  }
843 }
844 
845 void MmomeGui::updateRecentFileActions()
846 {
847  QSettings settings(QCoreApplication::applicationDirPath() + "/qss-solver.ini", QSettings::IniFormat);
848 
849  QStringList files = settings.value("Editor/recentFileList").toStringList();
850 
851  int numRecentFiles = qMin(files.size(), (int)MaxRecentFiles);
852 
853  for (int i = 0; i < numRecentFiles; ++i) {
854  QString text = tr("&%1 %2").arg(i + 1).arg(strippedName(files[i]));
855  recentFileActs[i]->setText(text);
856  recentFileActs[i]->setData(files[i]);
857  recentFileActs[i]->setVisible(true);
858  }
859  for (int j = numRecentFiles; j < MaxRecentFiles; ++j) recentFileActs[j]->setVisible(false);
860 
861  separatorAct->setVisible(numRecentFiles > 0);
862 }
863 
864 void MmomeGui::loadFile(QString fileName)
865 {
866  editModel(fileName);
867  addVariables();
868  setCurrentFile(fileName);
869 }
870 
871 void MmomeGui::setCurrentFile(const QString fileName)
872 {
873  _curFile = fileName;
874  setWindowFilePath(_curFile);
875  QSettings settings(QCoreApplication::applicationDirPath() + "/qss-solver.ini", QSettings::IniFormat);
876  QStringList files = settings.value("Editor/recentFileList").toStringList();
877  files.removeAll(fileName);
878  files.prepend(fileName);
879  while (files.size() > MaxRecentFiles) files.removeLast();
880 
881  settings.setValue("Editor/recentFileList", files);
882  updateRecentFileActions();
883 }
884 
885 void MmomeGui::selectVariables()
886 {
887  QString name = Editor::instance()->activeBaseFileName();
888  bool found = false;
889  for (int k = 0; k < _model->rowCount(); k++) {
890  QStandardItem *it = _model->item(k);
891  Qt::CheckState cs = Qt::Unchecked;
892  if (name == it->text()) {
893  cs = Qt::Checked;
894  QModelIndex idx = _model->index(k, 0, QModelIndex());
895  _model_variables->setExpanded(idx, true);
896  found = true;
897  } else {
898  QModelIndex idx = _model->index(k, 0, QModelIndex());
899  _model_variables->setExpanded(idx, false);
900  }
901  for (int g = 0; g < it->rowCount(); g++) {
902  QStandardItem *c = it->child(g, 1);
903  QString name = c->text();
904  c->setCheckState(cs);
905  }
906  }
907  if (!found) {
908  addVariables();
909  int k = _model->rowCount() - 1;
910  if (k < 0) return;
911  QStandardItem *it = _model->item(k);
912  Qt::CheckState cs = Qt::Checked;
913  QModelIndex idx = _model->index(k, 0, QModelIndex());
914  _model_variables->setExpanded(idx, true);
915  for (int g = 0; g < it->rowCount(); g++) {
916  QStandardItem *c = it->child(g, 1);
917  QString name = c->text();
918  c->setCheckState(cs);
919  }
920  }
921 }
922 
923 void MmomeGui::addVariables()
924 {
925  QString name = Editor::instance()->activeBaseFileName();
926  for (int k = 0; k < _model->rowCount(); k++) {
927  QStandardItem *it = _model->item(k);
928  if (name == it->text()) {
929  return;
930  }
931  }
932  if (!name.isEmpty()) {
933  QString fdir;
934  fdir.append(_utils->appDir(MMOC_OUTPUT)).append(SLASH).append(name);
935  _model->addFiles(fdir);
936  _model_variables->setModel(_model);
937  _model_variables->setModel(_model);
938  _model_variables->setItemDelegateForColumn(2, _cboxd);
939  for (int column = 0; column < _model->columnCount(); ++column) {
940  _model_variables->resizeColumnToContents(column);
941  }
942  }
943 }
944 
945 void MmomeGui::on_actionGraphics_triggered()
946 {
947  QString name = Editor::instance()->activeBaseFileName();
948  if (name.isEmpty()) return;
949  if (!plotScript()) {
950  return;
951  }
952  _compiler_msg->clear();
953  QString plotCmd = _utils->appCommand(CMD_PLOT);
954  QString plotOptions = _utils->appFlag(FLG_PLOT);
955  QString gpxdir = _utils->appDir(MMOC_OUTPUT) + SLASH + name;
956  QFileInfo of(gpxdir + SLASH + name + QString(".plt"));
957  if (!of.exists()) {
958  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + QString("\n Can't find plot script: ") + name + QString(".plt"));
959  return;
960  }
961  _plot = new QProcess(this);
962  connect(_plot, QOverload<int, QProcess::ExitStatus>::of(&QProcess::finished), this, &MmomeGui::plot_finished);
963  QStringList args;
964  if (plotOptions.isEmpty()) {
965  plotOptions = "-persist";
966  }
967  args << plotOptions;
968  args << of.absoluteFilePath();
969  _plot->start(plotCmd, args);
970 }
971 
972 void MmomeGui::plot_finished(int exitCode, QProcess::ExitStatus exitStatus)
973 {
974  QString msgs = _plot->readAllStandardError();
975  if (exitStatus == QProcess::NormalExit && !msgs.isEmpty()) {
976  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + "\nPlot script error: " + QString::number(exitCode) + "\n" + msgs);
977  }
978  delete _plot;
979  _plot = NULL;
980 }
981 
982 void MmomeGui::on_actionExit_triggered() { close(); }
983 
984 void MmomeGui::on_actionAbout_triggered()
985 {
986  QString sh;
987  sh.append("Modeling and simulation environment for continuous and hybrid systems.\n");
988  sh.append("Version: ");
989  sh.append(_utils->appFlag(FLG_VERSION));
990  sh.append("\n");
991  sh.append("Branch: ");
992  sh.append(_utils->appFlag(FLG_BRANCH));
993  sh.append("\n");
994  sh.append("HomePage: ");
995  sh.append("https://github.com/CIFASIS/qss-solver\n");
996  sh.append("Developed by:\n");
997  sh.append("Joaquin Fernandez (fernandez@cifasis-conicet.gov.ar)\n");
998  sh.append("\n");
999  sh.append("Directed by:\n");
1000  sh.append("Ernesto Kofman (kofman@cifasis-conicet.gov.ar)\n");
1001  QString title("QSS Solver");
1002  QMessageBox::about(this, title, sh);
1003 }
1004 
1005 QString MmomeGui::strippedName(const QString &fullFileName) { return QFileInfo(fullFileName).fileName(); }
1006 
1007 void MmomeGui::log_finished(int exitCode, QProcess::ExitStatus exitStatus)
1008 {
1009  QDir outputDir(_utils->appDir(MMOC_OUTPUT));
1010  outputDir.cd(Editor::instance()->activeBaseFileName());
1011  QFileInfo logfi(outputDir.absolutePath() + SLASH + Editor::instance()->activeBaseFileName() + QString(".log"));
1012  if (logfi.size()) {
1013  editModel(logfi.absoluteFilePath());
1014  } else if (exitStatus == QProcess::NormalExit) {
1015  QString msgs = _log->readAllStandardError();
1016  _compiler_msg->setPlainText(_compiler_msg->toPlainText() + "\nLog file error: " + QString::number(exitCode) + "\n" + msgs);
1017  }
1018  delete _log;
1019  _log = NULL;
1020 }
RunDlg::symDiff
QString symDiff()
Definition: runform.hpp:61
ComboBoxDelegate
Definition: comboboxdelegate.hpp:28
CMD_SBML
@ CMD_SBML
Definition: utils.hpp:58
RunDlg::absTolerance
QString absTolerance()
Definition: runform.hpp:49
Editor::instance
static ModelEditor * instance(QWidget *parent=nullptr, QString name=QString())
Definition: editor.hpp:45
RunDlg::solver
QString solver()
Definition: runform.hpp:58
RunDlg::setMetisSettings
void setMetisSettings(QString str)
Definition: runform.hpp:95
MmomeGui::_python_console
QTermWidget * _python_console
Definition: mmomegui.hpp:108
RunDlg::setGenerateArch
void setGenerateArch(QString str)
Definition: runform.hpp:99
RunDlg::DT
QString DT()
Definition: runform.hpp:51
RunDlg::partitionMethod
QString partitionMethod()
Definition: runform.hpp:84
MMOC_SOURCE
@ MMOC_SOURCE
Definition: utils.hpp:51
treemodel.hpp
MmomeGui::_settingsDlg
SettingsDlg * _settingsDlg
Definition: mmomegui.hpp:104
RunDlg::setLPS
void setLPS(QString lps)
Definition: runform.hpp:81
MmomeGui::on_actionDebug_triggered
void on_actionDebug_triggered()
Definition: mmomegui.cpp:260
ModelEditor::setLPS
void setLPS(QString str)
Definition: modeleditor.hpp:86
MmomeGui::settingsDlgClosed
void settingsDlgClosed()
Definition: mmomegui.cpp:320
Utils::appFlag
QString appFlag(AppFlags f)
Definition: utils.cpp:78
ModelEditor::setOutput
void setOutput(QString str)
Definition: modeleditor.hpp:76
RunDlg::reorderPartition
QString reorderPartition()
Definition: runform.hpp:100
utils.hpp
MmomeGui::editModel
void editModel(QString name)
Definition: mmomegui.cpp:233
MmomeGui::_iniFile
QString _iniFile
Definition: mmomegui.hpp:97
ModelEditor::setScheduler
void setScheduler(QString str)
Definition: modeleditor.hpp:79
ModelEditor::setImbalance
void setImbalance(QString str)
Definition: modeleditor.hpp:110
MmomeGui::addToolBarItems
void addToolBarItems()
Definition: mmomegui.cpp:138
RunDlg::setSolver
void setSolver(QString str)
Definition: runform.hpp:74
ModelEditor::done
void done(QString name, QString ext)
runform.hpp
MmomeGui::_console
QTermWidget * _console
Definition: mmomegui.hpp:109
MMOC_BIN
@ MMOC_BIN
Definition: utils.hpp:50
MmomeGui::on_actionMicroModelica_Compiler_Documentation_triggered
void on_actionMicroModelica_Compiler_Documentation_triggered()
Definition: mmomegui.cpp:280
MmomeGui::deleteVariables
void deleteVariables(QString name)
Definition: mmomegui.cpp:799
MmomeGui::importFinished
void importFinished(int exitCode, QProcess::ExitStatus exitStatus)
Definition: mmomegui.cpp:624
MmomeGui::createActions
void createActions()
Definition: mmomegui.cpp:818
FLG_VERSION
@ FLG_VERSION
Definition: utils.hpp:54
RunDlg::setOutputType
void setOutputType(QString str)
Definition: runform.hpp:71
ModelEditor::setMetisSettings
void setMetisSettings(QString str)
Definition: modeleditor.hpp:104
RunDlg::BDFMaxStep
QString BDFMaxStep()
Definition: runform.hpp:110
ModelEditor::startTime
QString startTime()
Definition: modeleditor.hpp:61
MmomeGui::loadFile
void loadFile(QString fileName)
Definition: mmomegui.cpp:864
MMOC_LIBRARIES
@ MMOC_LIBRARIES
Definition: utils.hpp:53
MmomeGui::openRecentFiles
void openRecentFiles()
Definition: mmomegui.cpp:837
MmomeGui::simulation_message
void simulation_message()
Definition: mmomegui.cpp:370
MMOC_MODELS
@ MMOC_MODELS
Definition: utils.hpp:45
MmomeGui::plot_finished
void plot_finished(int exitCode, QProcess::ExitStatus exitStatus)
Definition: mmomegui.cpp:972
FLG_PLOT
@ FLG_PLOT
Definition: utils.hpp:53
settings.hpp
ModelEditor::setAbsTolerance
void setAbsTolerance(QString str)
Definition: modeleditor.hpp:68
CMD_COMPILE
@ CMD_COMPILE
Definition: utils.hpp:58
MmomeGui::selectVariables
void selectVariables()
Definition: mmomegui.cpp:885
RunDlg::startTime
QString startTime()
Definition: runform.hpp:59
RunDlg::parallel
QString parallel()
Definition: runform.hpp:83
RunDlg::BDFPartitionDepth
QString BDFPartitionDepth()
Definition: runform.hpp:108
MmomeGui::enableActions
void enableActions(bool f)
Definition: mmomegui.cpp:119
RunDlg::BDFPart
QString BDFPart()
Definition: runform.hpp:106
MmomeGui::initialize
void initialize()
Definition: mmomegui.cpp:72
MmomeGui::plotScript
bool plotScript()
Definition: mmomegui.cpp:483
MmomeGui::recentFileActs
QAction * recentFileActs[MaxRecentFiles]
Definition: mmomegui.hpp:111
CMD_LOG
@ CMD_LOG
Definition: utils.hpp:58
RunDlg::enableDebug
bool enableDebug()
Definition: runform.hpp:89
ModelEditor::setPartitionMethod
void setPartitionMethod(QString str)
Definition: modeleditor.hpp:92
RunDlg::setJacobian
void setJacobian(QString str)
Definition: runform.hpp:82
MmomeGui::_settings_only
bool _settings_only
Definition: mmomegui.hpp:105
RunDlg::zcHyst
QString zcHyst()
Definition: runform.hpp:64
MmomeGui::MmomeGui
MmomeGui()
Definition: mmomegui.cpp:56
CMD_SIMULATE
@ CMD_SIMULATE
Definition: utils.hpp:58
SettingsDlg
Definition: settings.hpp:28
ModelEditor::setParallel
void setParallel(QString str)
Definition: modeleditor.hpp:90
RunDlg::setMinStep
void setMinStep(QString str)
Definition: runform.hpp:68
MmomeGui::on_actionImport_triggered
void on_actionImport_triggered()
Definition: mmomegui.cpp:205
MmomeGui::on_actionGraphics_triggered
void on_actionGraphics_triggered()
Definition: mmomegui.cpp:945
MmomeGui::separatorAct
QAction * separatorAct
Definition: mmomegui.hpp:113
RunDlg::setImbalance
void setImbalance(QString str)
Definition: runform.hpp:105
RunDlg::setStartTime
void setStartTime(QString str)
Definition: runform.hpp:75
ModelEditor::setScotchSettings
void setScotchSettings(QString str)
Definition: modeleditor.hpp:103
ModelEditor::setSolver
void setSolver(QString str)
Definition: modeleditor.hpp:80
Utils
Definition: utils.hpp:60
ModelEditor::setSymDiff
void setSymDiff(QString str)
Definition: modeleditor.hpp:83
ModelEditor::setZcHyst
void setZcHyst(QString str)
Definition: modeleditor.hpp:85
RunDlg::scotchSettings
QString scotchSettings()
Definition: runform.hpp:92
RunDlg::setZcHyst
void setZcHyst(QString str)
Definition: runform.hpp:79
editor.hpp
MmomeGui::on_actionCompile_triggered
void on_actionCompile_triggered()
Definition: mmomegui.cpp:734
RunDlg::patohSettings
QString patohSettings()
Definition: runform.hpp:90
MmomeGui::on_actionLog_triggered
void on_actionLog_triggered()
Definition: mmomegui.cpp:766
RunDlg
Definition: runform.hpp:27
RunDlg::jacobian
QString jacobian()
Definition: runform.hpp:62
MmomeGui::strippedName
QString strippedName(const QString &fullFileName)
Definition: mmomegui.cpp:1005
ModelEditor::setDebugGraph
void setDebugGraph(QString str)
Definition: modeleditor.hpp:114
ModelEditor::baseFileName
QString baseFileName(int idx)
Definition: modeleditor.cpp:190
MmomeGui::run_finished
void run_finished(int exitCode, QProcess::ExitStatus exitStatus)
Definition: mmomegui.cpp:292
MMOC_INCLUDE
@ MMOC_INCLUDE
Definition: utils.hpp:54
MmomeGui::exitAct
QAction * exitAct
Definition: mmomegui.hpp:114
ModelEditor::setPeriod
void setPeriod(QString str)
Definition: modeleditor.hpp:78
MmomeGui::comp_finished
void comp_finished(int exitCode, QProcess::ExitStatus exitStatus)
Definition: mmomegui.cpp:669
MmomeGui::_plot
QProcess * _plot
Definition: mmomegui.hpp:100
RunDlg::output
QString output()
Definition: runform.hpp:54
RunDlg::stopTime
QString stopTime()
Definition: runform.hpp:60
MmomeGui::_proc
QProcess * _proc
Definition: mmomegui.hpp:99
MmomeGui::addVariables
void addVariables()
Definition: mmomegui.cpp:923
SLASH
#define SLASH
Definition: mmomegui.cpp:38
ModelEditor::setDerDelta
void setDerDelta(QString str)
Definition: modeleditor.hpp:69
ModelEditor::setStopTime
void setStopTime(QString str)
Definition: modeleditor.hpp:82
TreeModel
Definition: treemodel.hpp:33
comboboxdelegate.hpp
RunDlg::setParallel
void setParallel(QString str)
Definition: runform.hpp:85
ModelEditor::setTolerance
void setTolerance(QString str)
Definition: modeleditor.hpp:84
MMOC_OUTPUT
@ MMOC_OUTPUT
Definition: utils.hpp:46
FLG_DEBUG
@ FLG_DEBUG
Definition: utils.hpp:41
ModelEditor::setBDFPartitionDepth
void setBDFPartitionDepth(QString str)
Definition: modeleditor.hpp:121
ModelEditor::setDT
void setDT(QString str)
Definition: modeleditor.hpp:95
RunDlg::setDescription
void setDescription(QString str)
Definition: runform.hpp:67
ModelEditor::setSemiStaticPartitioning
void setSemiStaticPartitioning(bool st)
Definition: modeleditor.hpp:108
RunDlg::setDerDelta
void setDerDelta(QString str)
Definition: runform.hpp:66
MmomeGui::MaxRecentFiles
@ MaxRecentFiles
Definition: mmomegui.hpp:110
Editor::drop
static void drop()
Definition: editor.hpp:52
MmomeGui::_log
QProcess * _log
Definition: mmomegui.hpp:101
RunDlg::dtSynch
QString dtSynch()
Definition: runform.hpp:87
MmomeGui::_utils
Utils * _utils
Definition: mmomegui.hpp:107
mmomegui.hpp
MmomeGui::cleanBuildDir
void cleanBuildDir(int)
Definition: mmomegui.cpp:541
ModelEditor::closeFiles
void closeFiles()
Definition: modeleditor.cpp:258
MmomeGui::on_actionClear_Log_triggered
void on_actionClear_Log_triggered()
Definition: mmomegui.cpp:784
MmomeGui::on_action_New_triggered
void on_action_New_triggered()
Definition: mmomegui.cpp:231
RunDlg::setBDFPart
void setBDFPart(QString str)
Definition: runform.hpp:107
MMOC_PACKAGES
@ MMOC_PACKAGES
Definition: utils.hpp:52
ModelEditor::save
void save(void)
Definition: modeleditor.cpp:276
MmomeGui::on_actionRun_triggered
void on_actionRun_triggered()
Definition: mmomegui.cpp:439
RunDlg::debugGraph
QString debugGraph()
Definition: runform.hpp:102
RunDlg::imbalance
QString imbalance()
Definition: runform.hpp:104
MmomeGui::runDlgRejected
void runDlgRejected()
Definition: mmomegui.cpp:380
RunDlg::minStep
QString minStep()
Definition: runform.hpp:53
MmomeGui::_timeInterval
double _timeInterval
Definition: mmomegui.hpp:106
RunDlg::derDelta
QString derDelta()
Definition: runform.hpp:50
RunDlg::setSemiStaticPartitioning
void setSemiStaticPartitioning(bool st)
Definition: runform.hpp:97
MmomeGui
Definition: mmomegui.hpp:33
RunDlg::setAbsTolerance
void setAbsTolerance(QString str)
Definition: runform.hpp:65
FLG_BRANCH
@ FLG_BRANCH
Definition: utils.hpp:55
mainWindow
MmomeGui * mainWindow
Definition: mmomegui.cpp:40
ModelEditor::setBDFPart
void setBDFPart(QString str)
Definition: modeleditor.hpp:119
MmomeGui::closeEvent
void closeEvent(QCloseEvent *event)
Definition: mmomegui.cpp:179
ModelEditor::saveAll
void saveAll(void)
Definition: modeleditor.cpp:307
ModelEditor::setPatohSettings
void setPatohSettings(QString str)
Definition: modeleditor.hpp:102
Utils::appCommand
QString appCommand(AppCmds c)
Definition: utils.cpp:22
ModelEditor::setDtSynch
void setDtSynch(QString str)
Definition: modeleditor.hpp:96
ModelEditor::stopTime
QString stopTime()
Definition: modeleditor.hpp:62
MmomeGui::on_actionQSS_Solver_Engine_Documentation_triggered
void on_actionQSS_Solver_Engine_Documentation_triggered()
Definition: mmomegui.cpp:274
RunDlg::description
QString description()
Definition: runform.hpp:52
FLG_FLAGS
@ FLG_FLAGS
Definition: utils.hpp:52
MmomeGui::on_actionRun_2_triggered
void on_actionRun_2_triggered()
Definition: mmomegui.cpp:433
MmomeGui::updateRecentFileActions
void updateRecentFileActions()
Definition: mmomegui.cpp:845
ModelEditor::activeBaseFileName
QString activeBaseFileName()
Definition: modeleditor.cpp:184
RunDlg::setOutput
void setOutput(QString str)
Definition: runform.hpp:70
ModelEditor::setJacobian
void setJacobian(QString str)
Definition: modeleditor.hpp:93
RunDlg::tolerance
QString tolerance()
Definition: runform.hpp:63
MmomeGui::log_finished
void log_finished(int exitCode, QProcess::ExitStatus exitStatus)
Definition: mmomegui.cpp:1007
MmomeGui::_runDlg
RunDlg * _runDlg
Definition: mmomegui.hpp:102
MmomeGui::runDlgClose
void runDlgClose()
Definition: mmomegui.cpp:382
RunDlg::setPartitionMethod
void setPartitionMethod(QString str)
Definition: runform.hpp:86
MmomeGui::compile
bool compile(bool dbg)
Definition: mmomegui.cpp:562
RunDlg::setScotchSettings
void setScotchSettings(QString str)
Definition: runform.hpp:93
RunDlg::semiStaticPartitioning
bool semiStaticPartitioning()
Definition: runform.hpp:96
MmomeGui::addMenuBarItems
void addMenuBarItems()
Definition: mmomegui.cpp:159
MMOC_ENGINE
@ MMOC_ENGINE
Definition: utils.hpp:48
RunDlg::setDT
void setDT(QString str)
Definition: runform.hpp:69
RunDlg::outputType
QString outputType()
Definition: runform.hpp:55
ModelEditor::writeAnnotations
void writeAnnotations()
Definition: modeleditor.cpp:749
INIT_PYTHON
static const QString INIT_PYTHON
Definition: mmomegui.cpp:42
CMD_BUILD
@ CMD_BUILD
Definition: utils.hpp:58
MmomeGui::on_actionClear_Messages_triggered
void on_actionClear_Messages_triggered()
Definition: mmomegui.cpp:797
RunDlg::setTolerance
void setTolerance(QString str)
Definition: runform.hpp:78
MMOC_LIBS
@ MMOC_LIBS
Definition: utils.hpp:49
RunDlg::LPS
QString LPS()
Definition: runform.hpp:80
RunDlg::setReorderPartition
void setReorderPartition(QString str)
Definition: runform.hpp:101
ModelEditor::activeFullFileName
QString activeFullFileName()
Definition: modeleditor.cpp:198
MmomeGui::on_actionSettings_triggered
void on_actionSettings_triggered()
Definition: mmomegui.cpp:197
ModelEditor::setMinStep
void setMinStep(QString str)
Definition: modeleditor.hpp:75
RunDlg::setDtSynch
void setDtSynch(QString str)
Definition: runform.hpp:88
MmomeGui::make_finished
void make_finished(int exitCode, QProcess::ExitStatus exitStatus)
Definition: mmomegui.cpp:638
ModelEditor::setDescription
void setDescription(QString str)
Definition: modeleditor.hpp:70
RunDlg::period
QString period()
Definition: runform.hpp:56
ModelEditor::setReorderPartition
void setReorderPartition(QString str)
Definition: modeleditor.hpp:112
MmomeGui::_model
TreeModel * _model
Definition: mmomegui.hpp:98
RunDlg::setDebugGraph
void setDebugGraph(QString str)
Definition: runform.hpp:103
CMD_PLOT
@ CMD_PLOT
Definition: utils.hpp:58
MmomeGui::on_actionExit_triggered
void on_actionExit_triggered()
Definition: mmomegui.cpp:982
RunDlg::setScheduler
void setScheduler(QString str)
Definition: runform.hpp:73
RunDlg::setBDFMaxStep
void setBDFMaxStep(QString d)
Definition: runform.hpp:111
RunDlg::scheduler
QString scheduler()
Definition: runform.hpp:57
MmomeGui::done
void done(QString name, QString ext)
Definition: mmomegui.cpp:165
RunDlg::generateArch
QString generateArch()
Definition: runform.hpp:98
RunDlg::setPatohSettings
void setPatohSettings(QString str)
Definition: runform.hpp:91
MmomeGui::on_action_Save_As_triggered
void on_action_Save_As_triggered()
Definition: mmomegui.cpp:189
TreeModel::addFiles
void addFiles(QString dir)
Definition: treemodel.cpp:40
MmomeGui::_sbmlFile
QString _sbmlFile
Definition: mmomegui.hpp:103
ModelEditor::setStartTime
void setStartTime(QString str)
Definition: modeleditor.hpp:81
MmomeGui::on_actionSBML_Translator_Documentation_triggered
void on_actionSBML_Translator_Documentation_triggered()
Definition: mmomegui.cpp:286
MmomeGui::on_actionAbout_triggered
void on_actionAbout_triggered()
Definition: mmomegui.cpp:984
RunDlg::setBDFPartitionDepth
void setBDFPartitionDepth(QString d)
Definition: runform.hpp:109
ModelEditor::clean
void clean(int)
ModelEditor::editModel
void editModel(QString name=QString())
Definition: modeleditor.cpp:114
MmomeGui::on_action_Load_triggered
void on_action_Load_triggered()
Definition: mmomegui.cpp:251
ModelEditor::saveAs
void saveAs(QString name=QString())
Definition: modeleditor.cpp:287
ModelEditor::setGenerateArch
void setGenerateArch(QString str)
Definition: modeleditor.hpp:116
RunDlg::setPeriod
void setPeriod(QString str)
Definition: runform.hpp:72
RunDlg::metisSettings
QString metisSettings()
Definition: runform.hpp:94
MmomeGui::~MmomeGui
~MmomeGui()
Definition: mmomegui.cpp:62
MmomeGui::_cboxd
ComboBoxDelegate * _cboxd
Definition: mmomegui.hpp:96
MmomeGui::run
void run(QString name)
Definition: mmomegui.cpp:322
MmomeGui::_curFile
QString _curFile
Definition: mmomegui.hpp:112
Utils::appDir
QString appDir(AppDirs d)
Definition: utils.cpp:28
RunDlg::setStopTime
void setStopTime(QString str)
Definition: runform.hpp:76
RunDlg::setSymDiff
void setSymDiff(QString str)
Definition: runform.hpp:77
ModelEditor::setBDFMaxStep
void setBDFMaxStep(QString str)
Definition: modeleditor.hpp:123
MmomeGui::on_actionMicroModelica_Language_Scpefication_triggered
void on_actionMicroModelica_Language_Scpefication_triggered()
Definition: mmomegui.cpp:268
ModelEditor::setOutputType
void setOutputType(QString str)
Definition: modeleditor.hpp:77
MMOC_BUILD
@ MMOC_BUILD
Definition: utils.hpp:47
MmomeGui::setCurrentFile
void setCurrentFile(const QString fileName)
Definition: mmomegui.cpp:871