fix notebook

scripts/plot-results.ipynb

 %% Cell type:code id: tags:
 
 ``` python
 import os
 import pandas as pd
 import numpy as np
 import plotly.io as pio
 import plotly.express as px
 import plotly.graph_objs as go
 from itertools import combinations
 from plotly.subplots import make_subplots
 
 # render figures in notebook
 pio.renderers.default = "notebook_connected"
 
 # templates figures
 px.defaults.template = "simple_white"
 pio.templates.default = "simple_white"
 
 # layout for all figures
 LAYOUT_FIGURES = dict(
     autosize=False,
     width = 500,
     height = 500,
     xaxis = dict(
       constrain="domain",
       mirror=True,
       showexponent="all",
       exponentformat="power"
     ),
     yaxis = dict(
       scaleanchor = "x",
       scaleratio = 1,
       mirror=True,
       showexponent="all",
       exponentformat="power"
     ),
     title = dict(
       y = 0.9,
       x = 0.5,
       xanchor = 'center',
       yanchor = 'top'
     )
 )
 ```
 
 %% Cell type:markdown id: tags:
 
 # Auxiliary Functions
 
 %% Cell type:code id: tags:
 
 ``` python
 def create_folder(path):
     """Creates a folder if it does not exist
 
     Parameters
     ----------
     path : str
         Path of the new folder
 
     Examples
     --------
 
     >>> create_folder('./results')
     """
     if not os.path.exists(path):
         os.makedirs(path)
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 def create_figure(df, model):
     """Creates a scatter figure showing the time taken by each tool to verify each property of a model
 
     Parameters
     ----------
     df : pandas.Dataframe
         Dataframe containing the results of the experiments
     model : string
         model to be plotted
 
     Returns
     -------
     plotly.graph_objects.Figure
         Scatter figure
 
     Examples
     --------
 
     >>> import os
     >>> import pandas as pd
     >>> csv_file = os.path.join("results", "output.csv")
     >>> df = pd.read_csv(csv_file)
     >>> fig = create_figure(df, 'philo10')
     """
     model_df = df[df.model == model]
 
     figure = px.scatter(model_df,
                         x="formula", y="time",
                         title=model,
                         color="tool",
                         symbol_sequence=['x'])
 
     figure.update_layout(yaxis_title="time (s)", title=LAYOUT_FIGURES['title'])
     return figure
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 def get_axis_title(experiment, show_strategy=True):
     """Get the axis title of a figure depending on the experiment being plotted
 
     Parameters
     ----------
     experiment : str
         String with the experiment information
     show_strategy : bool, optional
         Flag to show the information related to the strategy used by the tool
 
     Returns
     -------
     str
         axis title
 
     Examples
     --------
 
     >>> get_axis_title('pmc-sog_otfL_couv99-default_1_1', True)
     pmc-sog (Lace, strategy: couv99-default, # cores: 1)
     """
     information = experiment.split('_')
     tool_name = information[0]
 
     info = []
     library_dic = {
         'otfL': 'Lace',
         'otfP': 'Pthreads',
         'otfC': 'Cthreads',
         'otf': 'Hybrid'
     }
 
     if (len(information) == 5):
         info.append(library_dic[information[1]])
 
     if (show_strategy):
         info.append('strategy: {}'.format(information[-3]))
 
     nb_nodes = int(information[-2])
     if (nb_nodes > 1):
         info.append('# nodes: {}'.format(nb_nodes))
 
     info.append('# cores: {}'.format(information[-1]))
 
     title = '{} ({})'.format(tool_name, ', '.join(info))
 
     return title
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 def create_log_figure(table, table_errors, model, tool_x, tool_y, show_strategy=True, callback=None):
     """Creates a Scatter figure in logarithmic scale comparing the performance of two tools
 
     Parameters
     ----------
     table : pandas.Dataframe
         Dataframe with the times of each experiment
     table_errors : pandas.Dataframe
         Dataframe with the errors of each experiment
     model : string
         Model to be analyzed
     tool_x : string
         Tool to be compared and plotted on the x-axis
     tool_y : string
         Tool to be compared and plotted on the y-axis
     show_strategy : bool
         Flag to show the stretagy used by the tools
     callback : function
         Function to be called when clicking on a point
 
     Returns
     -------
     plotly.graph_objects.Figure
         Scatter figure
 
     Examples
     --------
     >>> import os
     >>> import pandas as pd
     >>> csv_file = os.path.join("results", "output.csv")
     >>> df = pd.read_csv(csv_file)
     >>> table = df.set_index(['model', 'formula', 'tool'], drop=True).unstack('tool')
     >>> fig = create_log_figure(table['time'], table['error'], 'philo10', 'pmc-sog_otfL_couv99-default_1_8', 'pmc-sog_otfP_couv99-default_1_8')
     """
     try:
         min_values = table.loc[model].min()
         max_values = table.loc[model].max()
 
         min_value = min(min_values[tool_x], min_values[tool_y])/2.
         min_value_log = np.log10(min_value)
 
         max_value = max(max_values[tool_x], max_values[tool_y])
         max_value_log = np.log10(max_value)
 
         table_model = table.loc[model]
         table_errors_model = table_error.loc[model]
 
         full_table_x = pd.concat([table_model[tool_x],table_model['property'], table_errors_model[tool_x]], axis=1)
         full_table_x.columns = ['time', 'property', 'error']
 
         full_table_y = pd.concat([table_model[tool_y],table_model['property'], table_errors_model[tool_y]], axis=1)
         full_table_y.columns = ['time', 'property', 'error']
 
         traces = [
             {"property": 'T', "color":"green"},
             {"property": 'F', "color":"red"},
             {"property": 'U', "color":"black"}
         ]
 
         figures = []
         for t in traces:
             # filter by verification output
             table_x = full_table_x[full_table_x.property == t['property']]
             table_y = full_table_y[full_table_y.property == t['property']]
 
             # custom data
             custom_data = list(zip(table_x.index, table_x.error,table_y.error))
 
             # tools
             metainfo = {
                 'model': model,
                 'tools': {'x': tool_x, 'y': tool_y},
                 'folder': os.path.join(os.path.abspath(os.pardir), "results")
             }
 
             figures.append(go.Scatter(x=table_x.time,
                                       y=table_y.time,
                                       name=t['property'],
                                       mode='markers',
                                       marker_symbol='circle-open',
                                       marker_color=t['color'],
                                       meta = metainfo,
                                       customdata=custom_data,
                                       hovertemplate =
                                         '<b>Formula # %{customdata[0]}</b><br>' +
                                         '<br><b>Times:</b><br>' +
                                         '<b>x:</b> %{x} s' +
                                         '<br><b>y:</b> %{y} s<br>' +
                                         '<br><b>Errors:</b><br>' +
                                         '<b>x:</b> %{customdata[1]}<br>' +
                                         '<b>y:</b> %{customdata[2]}',
                                         ))
 
         # Line
         figures.append(go.Scatter(x=[min_value, max_value],
                                     y=[min_value, max_value],
                                     mode='lines', showlegend=False,
                                     line=dict(color='black', width=1)))
 
         # Create figure
         figure = go.FigureWidget(figures)
         figure.update_layout(LAYOUT_FIGURES,
                              title_text=model,
                              hoverlabel=dict(bgcolor="white", align='auto'),
                              legend_title_text='property',
                              xaxis=dict(type='log', autorange=False, range=[min_value_log, max_value_log]),
                              yaxis=dict(type='log', autorange=False, range=[min_value_log, max_value_log]),
                              xaxis_title=get_axis_title(tool_x, show_strategy),
                              yaxis_title=get_axis_title(tool_y, show_strategy))
 
         # Add event
         if callback is not None:
             for i in range(len(figure.data)):
                 figure.data[i].on_click(callback)
 
         return figure
     except Exception as e:
         print("Error when ploting model: {} - tool_x: {} - tool_y: {}".format(model, tool_x, tool_y))
         print(e)
 ```
 
 %% Cell type:code id: tags:
 
 ``` python
 import webbrowser
 
 def get_filename(base_path, tool, model, model_instance, formula):
     """Returns the absolute path of the experiment log
 
     Parameters
     ----------
     base_path : string
         Path of the folder where logs are saved
     tool : string
         Tool name
     model : string
         Model name
     model_instance : string
         Name of the model instance
     formula : string
         Identifier of the formula
 
     Returns
     -------
     string
         Absolute path of the log file
 
     """
     information = tool.split('_')
 
     tool_name = information[0]
     tool_configuration = '_'.join(information[:-2])
     nb_nodes = information[-2]
     nb_cores = information[-1]
 
     experiment_folder = os.path.join(base_path, tool_name, tool_configuration, model, model_instance)
     filename = f'{tool_name}_{model_instance}-n{nb_nodes}-th{nb_cores}-f{formula}'
     absolute_path = os.path.join(experiment_folder, filename)
 
     return absolute_path
 
 def open_logs_callback(trace, points, selector):
     """Callback that open the log files when clicking on a point of the figure
 
     Parameters
     ----------
     trace : plotly.graph_objects.Figure
         the figure to attach the callback
     points : plotly.callbacks.Points
         points of the figure selected
     selector: plotly.callbacks.InputDeviceState
         Device information
     """
     inds = points.point_inds
     if (inds):
         index = inds[0]
 
         formula, error_x, error_y = trace['customdata'][index]
         model_instance = trace['meta']['model']
         model = ''.join(c for c in model_instance if not c.isdigit())
         tools = trace['meta']['tools']