user:gui:full [Promethee]

Graphical User Interface

This section presents the features of the Promethee GUI.

Project workflow

The project workflow of Promethee is presented on the following loop, which describes the typical sequence of a Promethee project.
The initial engineering step is to define the objective, with:
  • a code suitable to simulate the studied process,
  • engineering parameters useful to reach the objective (and available in the code),
  • possibly an algorithm support, like optimization to manage calculation cases with the code.

Once this first specification is done, the project sequence may start:
  1. build source data files for simulation (possibly with an external dedicated tool, like a CAD software),
  2. import and parameterize these files to include choosen “input” variables,
  3. choose interest output values provided by the code,
  4. [automated] run remote and parallel calulations with this code,
  5. [automated] parse all resulting files and extract output variables values,
  6. [optionnal] iterate the run step if the algorithm ask for,
  7. analyse results to conclude on the initial engineering objective or iterate project sequence if unsatisfied.

GUI workflow

This workflow is instantiated in the following Graphical User Interface on the left side, while the right side is a contextual panel, dedicated to user interaction during the project steps.
  • the workflow manager:
    , itself holding the three steps of the Promethee projects:
    • the “Data sets” zone, for input dataset importation, input/output modeling, engineering issue parameterization:
    • the “Calculations” zone, for running calculations:
    • the “Results” zone, for analyses and storage of Promethee projects:
  • the contextual panel:
    , providing dedicated panels for all previous situations.

Project management

Promethee allows to create, delete, load, save or restart a project depending on the project workflow position:
  • in “Data sets” zone:
    • create a new project using icon, select the main input file (or multiple to create several projects)
      alternatively just drag and drop an input file in the “Data sets” zone
    • delete the selected project using icon
    • save the selected project in a ”.pmp” directory using icon
    • load a previously saved project using icon and selecting the ”.pmp” directory
    • launch the selected project calculations using icon
  • in “Calculations” zone:
    • delete the selected project using icon
    • restart (put in “Data sets” zone) the selected project using icon
    • pause the selected project using icon
    • start the selected project using icon
      project is automatically started if number of running projects is less than configuration limit (generally 3 simultaneous running projects are authorized)
    • give higher/lower queue priority using or icon
  • in “Results” zone:
    • delete the selected project using icon
    • save the selected project in a ”.pmp” directory using icon
    • load a previously saved project using icon and selecting the ”.pmp” directory
    • restart (put in “Data sets” zone) the selected project using icon

Parameterizing input data

The following contextual zone is dedicated to abstraction of code & dataset as a numerical function,
  • the input being all variables defined in dataset,
  • the function being the code applied on dataset,
  • the output being all readable output produced by the code.
Practically, all following steps are unordered as soon as an input file is opened.

Model and data

The first step is to select the code (including its version) in the “Model” combo box after having added a new project using . The first models in the list are supposed to accept the input file. The Help button opens the web browser on a web page dedicated to code.The second optional step is to add/delete complementary input files (like libraries for instance).

Input file editor

The last step is to edit the imported input files one-by-one (current edited file is the one selected in “Dataset” list) to defined Promethee input parameters. The upper toolbar provides:
  • Edit/Cancel/Save actions (resp.):
    • Edit: authorizes to modify the current file
    • Cancel: restores the file before edition
    • Save: definitely apply the edition changes and parse the file to search/update “Input variables” and “Output values”.
  • Basic search feature typing any character in text field starts a circular case-sensitive search on whole input file (forward search launched by ).
    Note than green background notifies matchable search while red means “no occurrence found”.
  • Parameterizing syntax for:
    • Variables: !(…)
      ... !(x1), !(x2), !x3, !x4, !x5, !x6, !x7, !x8 ...
      string is interpreted as 8 variables: x1, x2, x3, x4, x5, x6, x7, x8 1)
    • Formulas: @[…]
      ... @[cos(!x1+!x2)] ...
      will not parse new variables, but automatically replce the string ”@[cos(!x1+!x2)]” by cos(x1+x2) numerical value, where x1 and x2 are variables.
    • Functions: #@: …
      #@: f <- function(x) {if (x>1) {x+1} else {cos(x)} }
      ... @[f(!x1)] ...
      will add the new function “f” in the Math. engine. It means that you can call anywhere in the dataset the function “f”. Note that the # character is the “line comment” character of the code.
    • Tests: #@? f(0.5) == 1.5
      #@: f <- function(x) {if (x>1) {x+1} else {cos(x)} }
      #@? f(0.5) == cos(0.5)
      ... @[f(!x1)] ...
      will check that the test expression is true, instead the project will not launch. This feature is especially useful when checking that functions are well written.

Extended parameterizing syntax examples

  • !(x1~0.123) means that default value for “x1” variable is “0.123”
  • !(x1~{0.1,0.2,0.3}) will setup x1 values to 0.1,0.2 and 0.3
  • !(x1~:g) will setup x1 as belonging to the “g” group of variables
  • @[cos(!x1+!x2)|0.000E00] means that when evaluating formula, only three decimal characters will be kept, and scientific formt will be used: “0.456E-01” for instance. More information on this formt pattern: see Java DecimalFormat doc
  • #@: f ← function(x) {x + !x1} is a possible syntax. The variable x1 is like a “global” variable for f (in fact it is roughly replced before any call to math. engine).

Function I/O

Finally, all previous changes are displayed in the above I/O tables: “Input variable” and “Output values”: In this case, 8 code input variables are found: “x1”, …, “x8” and one output scalar is expected: “z”.

Intermediate variables

If other variables are computed in the Math. environment:
#@: f <- function(x) {if (x>1) {x+1} else {cos(x)} }
#@: a <- 3.14
... @[f(!x1)+a] ...
, then these “intermediate” variables are presented in a third table between input and output ones.
Note that if the name of this intermediate variable starts with ”.”, it remains invisible for the user.

Managing code input/output

While previous “Model” zone was dedicated to define code input/output raw data, this contextual zone is intended to post-process these data to define:
  • X: “Input” variables as vectors of code input parameters, type 2), bounds or value(s),
  • Z: “Output” interest values as function of code output and variables,
  • “Engineering” algorithm 3) applied to investigate previous functional I/O expression: “Z=f(X)”.

Input variables

Two kind of variables are possible:
  • User defined variables:
    • possibly several values are given by user (at least one) double-clicking on red “change me” cell,
      Note: right click on values table provides features like affine sequences (like screenshot), spreadsheet paste, random sampling, …
    • all variables types are given as integer, float or string,
    • several code input parameters (with same number of values) should be considered as components of a multi-dimensional vector (named “group”) using icon,
  • Engineering variables:
    • only bounds are given as floats,
    • an engineering issue is intended to define values between these bounds.
If no “engineering variable” is defined, no “engineering issue” is available. Then, calculations will be launched for all user defined variables possible combinations. This “user defined” parametric project is often use to get raw response of code for given input variables values. In case both user defined variables and engineering ones are given, the engineering issue will be repeated for all possible combinations of user defined variables.

Output interest values

Several interest values are possible (add using icon), just the selected one will be used for engineering issue. Different kind of output are possible like arrays, multi-dimensional points, …

Engineering issue

Depending on engineering variables and selected output interest value type, several algorithms are suitable. When an algorithm is selected, its parameters are editable on the right side panel. Further informations are accessible through “Help” button, launching browser on dedicated web page.


As soon as icon in “Dataset” workflow panel is available, you can launch calculations. The project then moves to the “Calculations” workflow and different contextual panels are available.

Calculators pool

Contains the list of available Promethee daemons 4). Double click on a line details the configuration of daemon. This list is real time updated with a heartbeat protocol sent by Promethee daemons periodically.

Cases of calculations

While calculations are performed, the list of cases 5) is updated, allowing to follow whole project progress. Double click on its line opens file browser in temporary directory of a case.Note: previous results of project execution are stored in a cache directory to not run two times the same calculation. The input file and code are checked to be exactly the same than currently pending calculation, and if perfectly matching, cached output directory is used instead of really launching calculation on remote Promethee servers.


Depending on the designer selected, temporary results are sometime available. This panel offers a possible view of post-processing for temporary results.

Results and analysis

Once all needed calculations are performed, the project is moved in the “Results” workflow panel. Promethee then runs a background post-processing task to parse all results and optionally build engineering analyses. When finished, the project row is selectable to display final results.


The first contextual tab panel provides easy access to all input/output directory structure of finished project: each calculation has its own “input” and “output” directories containing (resp.) all input and output files.
Generally, directories are named explicitly with variables values: “x=0.123” or group aliases: ”@g=abcd”, but heavy path length limitations on Windows operating systems lead us to digest some parts of path in a cryptic shorter name like
“0B6CDD1DC58CA052DB4507BE2AAF853A” instead of
In the last node of theses directories, the “output” directory contains all returned files of calculation, left-click opens selected file in the right panel, while right-click opens a popup to allow :

Note: be careful of available free disk space needed by Promethee: many engineering issues will lead to hundreds of calculations, and thousands of input/output files.

Post processing

The post-processing panels display all results or analysis (in case an engineering issue was selected) in tables or plot.

Since Promethee 1.1, “parallel coordinates” plot (also known as cobweb, parplot, parcoord) is available to display all calculation results, whenever launched with or without algorithm. This extended interactive post-processing component is especially useful to display any variable versus any output, for all calculations.


To provide standalone access to Promethee projects results, an HTML report is automatically build to display statically all previous results and analyses.The report holds three main parts:
  • general informations about project:
  • results or analysis of project:
  • all calculations launched in project:
    This part of the report includes relative links to all directory structure and summary in a CSV file.
1) note that variable delimiters ”(” and ”)” are optional when unambiguity
2) integer, float or string
3) sensitivity analysis, uncertainties propagation, optimization, calibration, …
4) grey ones are not suitable due to lack of code needed
5) a “case” is one instance of input file with given variables value set
© IRSN - All right reserved - Legal information