Plots

f_plot

Code

function plots = f_plot(results, settings, model_folder)
% This function generates plots for various analysis results based on the
% provided data and settings.
% 
% Inputs:
% - rst: A structure containing results from different types of analyses
% (diag, opt, lsa, gsa, PLA).
% - stg: A structure containing settings for the plots.
% - mmf: A ModelMappingFramework object containing the model and data
% information.
%
% Outputs:
% - plots: A cell array of generated plots.
%
% Used Functions:
% - f_plot_scores: Generates a figure with scores.
% - f_plot_inputs: Generates a figure with inputs.
% - f_plot_outputs: Generates a figure with outputs.
% - f_plot_in_out: Generates a figure with input and output for all
% experiments.
% - f_plot_opt: Generates a figure with optimization results.
% - f_plot_lsa: Generates figures for Local Sensitivity Analysis.
% - f_plot_gsa_sensitivities: Generates figures for Global Sensitivity
% Analysis.
% - f_plot_PL: Generates a figure for Profile Likelihood Analysis.
%
% Variables:
% Loaded:
% - data_model: A variable from mmf object containing the data model.
% - Data: A variable containing data for generating plots.
% - sbtab: A variable containing sbtab information for generating plots.
%
% Initialized:
% - plots: A cell array for storing generated plot handles.


% Set default font and size for plot axes
set(0, 'defaultAxesFontName', 'Arial')
set(0, 'defaultAxesFontSize', 10)

% Display a message to inform the user that the plotting process has started
disp("Plotting ...")

% Retrieve data model from mmf
data_model = model_folder.model.data.data_model;

% Load data and sbtab from the data model
load(data_model, 'Data', 'sbtab')

% Initialize an empty array to store generated plot handles
plots = [];

% Check if the 'diag' field exists in the rst structure
if isfield(results, 'diag')
    % Generate and store figure with Scores
    plots = [plots;f_plot_scores(results.diag, settings, sbtab)];
    % Generate and store figure with Inputs
    plots = [plots;f_plot_inputs(results.diag, settings, sbtab)];
    % Generate and store figure with Outputs
    plots = [plots;f_plot_outputs(results.diag, settings, sbtab, Data, model_folder)];
    % Generate and store figure with Input and Output for all experiments
    plots = [plots;f_plot_in_out(results.diag, settings, sbtab, Data, model_folder)];
end

% Check if the 'opt' field exists in the rst structure
if isfield(results, 'opt')
    % Generate and store figure with optimization results
    plots = [plots;f_plot_opt(results, settings)];
end

% Check if the 'lsa' field exists in the rst structure
if isfield(results, 'lsa')
    % Generate and store figures for Local Sensitivity Analysis
    plots = [plots;f_plot_lsa(results.lsa, settings)];
end

% Check if the 'gsa' field exists in the rst structure
if isfield(results, 'gsa')
    % Generate and store figures for Global Sensitivity Analysis
    plots = [plots;f_plot_gsa_sensitivities(results.gsa, settings, sbtab)];
end

% Check if the 'PLA' field exists in the rst structure
if isfield(results, 'PLA')
    % Generate and store figure for Profile Likelihood Analysis
    plots = [plots;f_plot_PL(results, settings, model_folder)];
end
end

The function that calls all the custom plot functions when appropriate Plots diagnosis that are important to understand if everything is working as it was supposed, it , expected outputs, observed outputs and scores for the models and conditions specified.

• Inputs - rst, stg

• Outputs

  Figure Scores

  

  Total scores and scores per dataset given the parameters specified in stg.pa

  Code Figure Scores

  function plots =f_plot_scores(rst,stg,sbtab)
  % Generates a figure with scores for different experimental outputs and
  % parameter sets
  %
  % Inputs:
  % - rst: A struct array containing results of the simulations
  % - stg: A struct containing settings for the simulations
  % - sbtab: A struct containing information about the datasets used
  % 
  % Outputs:
  % - plots: A cell array containing the generated plots
  %
  % Functions Called:
  % - f_set_font_settings: A function to set the font settings for the plot
  % - f_renew_plot: Closes any existing figures with the specified name and
  % then creates a new figure with the given name and properties. It returns
  % a 1x2 cell array containing the figure name and the figure handle.
  %
  % Variables
  % Loaded:
  % - None
  %
  % Initialized:
  % - layout: A tiled layout object for arranging plots within the figure
  % - diag_idx: Indices for the different parameter sets
  % - score_diag: Total scores for each parameter set
  % - title_texts: Different title texts based on the settings
  % - title_text: The chosen title text for the top plot
  % - label: Labels for the heatmap rows
  % - heatline: Data matrix for the heatmap
  % - h: A heatmap object
  %
  % Persistent:
  % - None
  
  %Font settings
  f_set_font_settings()
  
  % Inform the user that fig1 is being ploted
  disp("Plotting Scores")
  
  % Closes previous instances of the figure and generates a new one
  plots = f_renew_plot('Scores');
  
  layout = tiledlayout(5,1,'Padding','tight','TileSpacing','tight');
  
  % Generate top plot of Scores figure
  nexttile(layout,[1 1]);
  
  diag_idx = 1:numel(stg.pat);
  score_diag = [rst(stg.pat).st];
  
  % Plot the total scores of each parameter array to test
  scatter(diag_idx,score_diag,20,'filled')
  ylabel('Total Score (s_t)', 'FontSize', Axis_FontSize, 'FontWeight', Axis_Fontweight)
  set(gca,'xtick',[])
  % set(gca,'FontSize',10,'Fontweight','bold')
  
  % Choose correct title according to settings
  title_texts = ["Sum of the Score of all Experiments (s_t)",...
      "Sum of the Log base 10 of the Score of each Experimental Output", ...
      "Sum of the Log base 10 of the Score of each Experiment", ...
      "Log base 10 of sum of the Score of all Experiments", ...
      "Sum of the Score of all Experiments (s_t)"];
  title_text = title_texts(stg.useLog+1);
  title(title_text,...
      "FontSize",Minor_title_FontSize,"FontWeight",Minor_title_Fontweight)
  
  % Choose the bounds for the x axis so it aligns with the bottom plot
  xlim([min(diag_idx)-0.5 max(diag_idx)+0.5])
  
  % Generate bottom plot of figure 1
  nexttile(layout,[4 1]);
  
  % Generate labels for left of heatmap (Experiment number Dataset number)
  label = arrayfun(@(n) strcat("E", num2str(n-1), " ", ...
      strrep(string(sbtab.datasets(n).output_name), "_", "\_")), ...
      stg.exprun, 'UniformOutput', false);
  label = horzcat(label{:});
  
  heatline = cell2mat(arrayfun(@(k) cell2mat(arrayfun(@(n) rst(k).sd(:, n)', ...
      stg.exprun, 'UniformOutput', false))', stg.pat, 'UniformOutput', false));
  
  heatline( ~any(heatline,2), : ) = [];
  
  % Plot the heatmap
  h = heatmap(heatline,'Colormap',turbo,'YDisplayLabels',label,...
      'GridVisible','off','FontSize',7);
  h.CellLabelFormat = '%.2e';
  
  h.Title = "\fontsize{10} \bf Score of each Experimental Output (s_d)";
  h.XLabel = '\fontsize{8} \bf Parameter sets (\theta)';
  h.YLabel = '\fontsize{8} \bf Experimental Outputs';
  end
  

  
  

  Figure Inputs

  

  Checks inputs to the model

  Code Figure Inputs

  function plots = f_plot_inputs(rst,stg,sbtab)
  % This function generates a figure containing a series of subplots, with
  % each subplot representing the inputs of an individual experiment. The
  % function also adjusts the layout and formatting of the figure according
  % to the given font settings.
  %
  % Inputs:
  % - rst: A structure containing the results of the experiments
  % - stg: A structure containing experiment settings (e.g., exprun, pat)
  % - sbtab: A structure containing datasets and their associated information
  % - font_settings: A structure containing font settings for the plots
  %
  % Outputs:
  % - plots: A cell array containing the generated plots
  %
  % Functions called:
  % - set_font_settings: Apply font settings to the current function scope
  % - f_get_subplot: Calculate subplot positions and generate figures
  %
  % Variables
  % Loaded:
  % None
  % 
  % Initialized:
  % - plot_n: Counter for the number of plots
  % - fig_n: Counter for the number of figures
  % - layout: The layout of the plots in the figure
  % - plots_1: Temporary storage for the generated plots
  % - labelfig2: Labels for each input in the experiment
  % - Lgnd: Legend for the plots
  %
  % Persistent:
  % None
  
  
  % Inform the user that diagnosis inputs are beeing ploted
  disp("Plotting Inputs")
  
  plot_n = 0;
  fig_n = 0;
  layout = [];
  % plots_1 = [];
  
  % Set font settings
  f_set_font_settings()
  
  % Iterate over the number of experiments
  for n = stg.exprun
  
      % Generate the right amount of figures for all plots and calculates
      % proper subploting position
      if mod(plot_n,12) == 0
          [fig_n,layout,plots(fig_n,:)] = f_get_subplot(size(stg.exprun,2),plot_n,fig_n,"Inputs",layout);
  
          % Set figure name based on its order
          if fig_n > 1
              fig_name = "Inputs " + fig_n;
          else
              fig_name = "Inputs";
          end
          title(layout,fig_name,...
              'FontSize', Major_title_FontSize,'Fontweight',Major_title_Fontweight)
      end
  
      nexttile(layout);
  
      plot_n = plot_n +1;
  
      hold on
  
      % Iterate over the number of inputs in each experiment
      for j = 1:size(sbtab.datasets(n).input,2)
  
          % Iterate over the number of parameter arrays to test
          for m = stg.pat
  
              % (Until a non broken simulation is found)
              if rst(m).simd{1,n} ~= 0
  
                  % Plot the inputs to each experiment
                  plot(rst(m).simd{1,n}.Time,rst(m).simd{1,n}.Data(1:end,...
                      str2double(strrep(sbtab.datasets(n).input(j),'S',''))+1),'LineWidth',line_width)
  
                  % Get the correct label for each input of the experiment
                  labelfig2(j) = rst(m).simd{1,n}.DataNames(str2double(...
                      strrep(sbtab.datasets(n).input(j),'S',''))+1);
  
                  % Set y-axis label
                  ylabel(layout,string(rst(m).simd{1,n}.DataInfo{...
                      str2double(strrep(sbtab.datasets(n).input(j),'S',''))+1,1}.Units),...
                      'FontSize', Axis_FontSize,'Fontweight',Axis_Fontweight)
  
                  break
              end
          end
      end
  
      % Set x-axis label for the first plot in a row
      if mod(plot_n,12) == 1
  
          xlabel(layout,"Seconds", 'FontSize', Axis_FontSize,'Fontweight',Axis_Fontweight)
  
          % Create legend
          Lgnd = legend(labelfig2,'Orientation','vertical', ...
              'FontSize', Legend_FontSize,'Fontweight',Legend_Fontweight,...
              'Location','layout','Box','off');
          Lgnd.Layout.Tile = 'East';
          Lgnd.ItemTokenSize = Legend_ItemTokenSize;
      end
  
      % Set y-axis limit and format
      ylim([0 inf])
      ytickformat('%-4.1f')
  
      % Add a title to each plot
      title("E"+(n-1))
  
      hold off
  end
  end
  

  
  

  Figure Outputs

  

  Expected outputs, observed outputs

  Code Figure Outputs

  function plots = f_plot_outputs(rst,stg,sbtab,Data,mmf)
  % Generates a figure containing multiple subplots representing experimental
  % outputs for each experiment and dataset. The function loops through each
  % experiment and dataset and plots the results based on specified settings.
  % The font properties for plot elements are set using the
  % `set_font_settings` function.
  %
  % Inputs:
  % - rst: Results object containing simulation results and data information
  % - stg: Settings object containing various settings, such as experiment
  % run and parameter array
  % - sbtab: SBtab object containing datasets and output information
  % - Data: Data object containing experimental data and error information
  % - mmf: A flag to determine whether to normalize the simulation results
  % - font_settings: A structure containing font properties for plot elements
  %
  % Outputs:
  % - plots: A cell array containing figures and layouts generated
  % by the function
  %
  % Functions called:
  % - f_get_outputs: Get the total number of outputs to set the total number
  % of plots
  % - set_font_settings: Set the font properties for plot elements using the
  % provided font_settings
  % - f_get_subplot: Generate the required number of figures for all plots
  % and calculate proper subplot positioning
  % - f_error_area: Plot the error area
  % - f_normalize: Normalize simulation results
  %
  % Variables:
  % Loaded:
  % None
  %
  % Initialized:
  % - plot_tn: Total number of plots
  % - plot_n: Current plot number
  % - fig_n: Current figure number
  % - layout: TiledLayout object for subplots
  % - plots_1: Cell array to store figures and layouts temporarily
  %
  % Persistent:
  % None
  
  % Display a message indicating that the outputs are being plotted
  disp("Plotting Outputs")
  
  % Get the total number of outputs to set the total number of plots
  [plot_tn,~] = f_get_outputs(stg,sbtab);
  plot_n = 0;
  fig_n = 0;
  layout = [];
  % plots_1 = [];
  plots = cell(1,2);
  plot_tn = plot_tn *2;
  
  % Set font settings using the provided font_settings
  f_set_font_settings()
  
  % Loop through each experiment
  for n = stg.exprun
  
      
  
  
      % Loop through each dataset in the current experiment
      for j = 1:size(sbtab.datasets(n).output,2)
   
          for k = 1:2
          % Generate the required number of figures for all plots and calculate
          % proper subplot positioning
          if mod(plot_n,12) == 0
              [fig_n,layout,plots(fig_n,:)] =...
                  f_get_subplot(plot_tn,plot_n,fig_n,"Outputs",layout);
  
              if fig_n > 1
                  fig_name = "Outputs " + fig_n;
              else
                  fig_name = "Outputs";
              end
              title(layout,fig_name,...
                  'FontSize', Major_title_FontSize,...
                  'Fontweight',Major_title_Fontweight)
          end
  
          nexttile(layout);
          plot_n = plot_n + 1;
  
          hold on
  
          error_area_plotted = false;
  
          % Loop through each parameter array to test
          for m = stg.pat
  
              % Plot only if the simulation was successful
              if rst(m).simd{1,n} ~= 0
  
                  data = Data(n).Experiment.x(:,j);
  
                  data_SD = Data(n).Experiment.x_SD(:,j);
  
                  time = rst(m).simd{1,n}.Time;
  
                  if k == 1
                  % Plot the error area if it hasn't been plotted yet
                  if ~error_area_plotted
                      f_error_area(transpose(time), transpose([data-data_SD, data+data_SD]));
                      error_area_plotted = true;
                  end
                  end
                  % Normalize simulation results
                  % [sim_results,~,sim_results] = f_normalize(rst(m),stg,n,j,mmf);
                  % sim_results_detailed =[];
                  if k == 1
                      [sim_results,~,~] = f_normalize(rst(m),stg,n,j,mmf);
                      sim_results_detailed =[];
                  else
                      [~,~,sim_results] = f_normalize(rst(m),stg,n,j,mmf);
                      sim_results_detailed =[];
                  end
                  
  
                  % Plot detailed simulation results if enabled in settings
                  if stg.simdetail
                      time_detailed = rst(m).simd{1,n+2*stg.expn}.Time;
                      [~,sim_results_detailed]= f_normalize(rst(m),stg,n,j,mmf);
  
                      plot(time_detailed,sim_results_detailed,'DisplayName',...
                          string("\theta_"+m),'LineWidth',line_width)
  
                  else
                      plot(time,sim_results,'DisplayName',...
                          string("\theta_"+m),'LineWidth',line_width)
                  end
  
                  % Set the y-axis label
                  ylabel(string(rst(m).simd{1,n}.DataInfo{end-...
                      size(sbtab.datasets(n).output,2)+j,1}.Units),...
                      'FontSize', Axis_FontSize,'Fontweight',Axis_Fontweight)
              end
          end
  
          hold off
  
          % Set the y-axis limits
          min_y = min([0, min(sim_results), min(data - data_SD), min(data),...
              stg.simdetail * min(sim_results_detailed)]);
          ylim([min_y, inf]);
  
          % Choose the appropriate title based on the settings
          if stg.plotoln == 1
              title_text = "E" + (n-1) + " " +...
                  strrep(string(sbtab.datasets(n).output_name{1,j}),'_','\_');
          else
              title_text = "E" + (n-1) + " " +...
                  string(sbtab.datasets(n).output{1,j});
          end
  
          % Set the title for the subplot
          title(title_text, 'FontSize', Minor_title_FontSize,...
              'Fontweight', Minor_title_Fontweight);
  
          % Set the number of decimal places for the y-axis
          ytickformat('%-4.1f')
          % Add a legend to the plot
          if mod(plot_n,12) == 1
  
              Lgnd = legend('show','Orientation','vertical',...
                  'FontSize', Legend_FontSize,'Fontweight',Legend_Fontweight,...
                  'Location','layout');
              Lgnd.Layout.Tile = 'East';
              Lgnd.ItemTokenSize = Legend_ItemTokenSize;
              xlabel(layout,"Seconds",...
                  'FontSize', Axis_FontSize,'Fontweight',Axis_Fontweight)
              % Remove the legend box
              set(Lgnd,'Box','off')
          end
          end
      end
  end
  end
  

  
  

  Figure Input and Outputs per experiment

  

  Combined figure of the inputs and outputs for each experiment, on the left side we have the inputs of the experiment and on the right side the outputs

  Code Figure Input and Outputs

  function plots = f_plot_in_out(rst,stg,sbtab,Data,mmf)
  % This function generates a figure displaying input and output data for all
  % experiments. The left side of the figure shows the inputs of the
  % experiment, and the right side shows the outputs.
  %
  % Inputs:
  % - rst: A structure containing the results of the simulations.
  % - stg: A structure containing various settings for the experiments and
  % simulations.
  % - sbtab: A structure containing information about the input and output
  % datasets.
  % - Data: A structure containing experimental data and standard
  % deviations.
  % - mmf: A structure containing information about the model.
  %
  % Outputs:
  % - plots: A cell array storing the names and figure handles of the
  % generated plots.
  %
  % Used Functions :
  % - f_plot_in_out_left: Plots the input data on the left side of the
  % figure.
  % - f_normalize: Normalizes the simulation results.
  % - f_error_area: Plots the standard deviation of the output data as an
  % error area.
  % - f_set_font_settings: Sets font settings for the plot.
  % - f_renew_plot: Closes any existing figures with the specified name and
  % then creates a new figure with the given name and properties. It returns
  % a 1x2 cell array containing the figure name and the figure handle.
  %
  % Variables
  % Loaded:
  % - time: Time array for simulations.
  % - data: Experimental data array.
  % - data_SD: Standard deviation array for experimental data.
  %
  % Initialized:
  % - fig_number: Keeps track of the total number of figures generated.
  % - fig_number_same_exp: Keeps track of the number of figures generated
  % for the same experiment.
  % - n_outputs_exp: The number of outputs for the current experiment.
  % - layout: A tiled layout for the figure.
  % - input_plot: A plot object for input data.
  % - valid_outputs: A list of valid outputs.
  % - valid_outputs_plots: A list of valid output plots.
  % - line_width, Axis_FontSize, Axis_Fontweight, Minor_title_FontSize,
  % Minor_title_Fontweight, Major_title_FontSize, Major_title_Fontweight,
  % Minor_Title_Spacing, Legend_FontSize, Legend_Fontweight,
  % Legend_ItemTokenSize: Font settings variables.
  
  
  
  % Display a message indicating that the inputs outputs are being plotted
  disp("Plotting Inputs Outputs")
  
  % Set font settings for the plot
  f_set_font_settings()
  
  % Initialize variables for plot management
  fig_number = 0;
  plots = cell(1,2);
  
  % Loop through each experiment run
  for n = stg.exprun
  
      % Get the number of outputs for the current experiment
      n_outputs_exp = size(sbtab.datasets(n).output,2);
  
      % Initialize variables for plot management within the same experiment
      fig_number_same_exp = 1;
      fig_number =fig_number+ 1;
  
      % Plot the left side of the figure with input data
      [layout,input_plot,plots] = ...
          f_plot_in_out_left(rst, stg, sbtab, fig_number_same_exp,...
          n_outputs_exp > 4, n, plots, fig_number);
  
      % Loop through each output of the current experiment
      for j = 1:n_outputs_exp
  
          % If the output number is greater than 4 times the figure number of
          % the same experiment, create a new layout for input data
          if j/4 > fig_number_same_exp
              fig_number_same_exp = fig_number_same_exp+1;
              fig_number = fig_number+ 1;
  
              % Plot the left side of the figure with input data
              [layout,input_plot,plots] = ...
                  f_plot_in_out_left(rst, stg,sbtab, fig_number_same_exp,...
                  n_outputs_exp > 4, n, plots, fig_number);
          end
  
          % Set up the layout for output data
          nexttile(layout,[1 1]);
          hold on
          valid_outputs = [];
  
          % Loop through each parameter array to test
          for m = stg.pat
  
              % Plot output data only if the simulation was successful
              if rst(m).simd{1,n} ~= 0
  
                  % Retrieve time, data and standard deviation from the
                  % experiment
                  time = rst(m).simd{1,n}.Time;
                  data = Data(n).Experiment.x(:,j);
                  data_SD = Data(n).Experiment.x_SD(:,j);
  
                  % Plot the output data
                  plot_data = plot(time,data,'LineWidth',0.5,...
                      'DisplayName','data','Color','k');
  
                  % Plot the standard deviation of the output data
                  plot_data_SD = f_error_area(transpose(time),...
                      transpose([data-data_SD,data+data_SD]));
                  break
              end
          end
  
          % Loop through each parameter array to test
          for m = stg.pat
  
              % Plot simulated output data only if the simulation was
              % successful
              if rst(m).simd{1,n} ~= 0
  
                  % Retrieve time and normalized simulation results
                  time = rst(m).simd{1,n}.Time;
                  [sim_results] = f_normalize(rst(m),stg,n,j,mmf);
  
                  % If simdetail is enabled, retrieve detailed time and
                  % simulation results
                  if stg.simdetail
                      time_detailed = rst(m).simd{1,n+2*stg.expn}.Time;
                      [~,sim_results_detailed] = ...
                          f_normalize(rst(m),stg,n,j,mmf);
                  end
  
                  % Plot the outputs to each dataset (new subplots) and
                  % parameter array to test that are simulated using
                  % Simbiology
  
                  % Plot simulated output data
                  if stg.simdetail
                      valid_outputs_plots(:,m) = plot(time_detailed,...
                          sim_results_detailed,'DisplayName',...
                          string("\theta_"+m),'LineWidth',line_width);
                  else
                      valid_outputs_plots(:,m) = plot(time,...
                          sim_results,...
                          'DisplayName',string("\theta_"+m),...
                          'LineWidth',line_width);
                  end
  
                  % Set ylabel with the correct units
                  ylabel(string(rst(m).simd{1,n}. ...
                      DataInfo{end-n_outputs_exp+j,1}.Units),...
                      'FontSize', Axis_FontSize,'Fontweight',Axis_Fontweight)
                  valid_outputs = [valid_outputs,m];
              end
  
          end
  
          hold off
  
          % Set ylim based on whether simdetail is enabled or not
          if stg.simdetail
              ylim([min([0,min(sim_results_detailed),min(sim_results),...
                  min(data-data_SD),min(data)]) inf])
          else
              ylim([min([0,min(sim_results),...
                  min(data-data_SD),min(data)]) inf])
          end
  
          % Set xlabel with correct font settings
          xlabel('Seconds','FontSize', Axis_FontSize,...
              'Fontweight',Axis_Fontweight)
  
          % Set title according to settings
          if stg.plotoln == 1
              [~,t2] = ...
                  title(strrep(string(sbtab.datasets(n).output_name{1,j}),...
                  '_','\_')," ",'FontSize',Minor_title_FontSize,...
                  'Fontweight',Minor_title_Fontweight);
          else
              [~,t2] = ...
                  title(string(sbtab.datasets(n).output{1,j}),...
                  " ",'FontSize',Minor_title_FontSize,...
                  'Fontweight',Minor_title_Fontweight);
          end
  
          t2.FontSize = Minor_Title_Spacing;
          % Set the number of decimal places for the y-axis
          ytickformat('%-3.1f')
          % Add a legend for the entire image
          leg = ...
              legend([input_plot,valid_outputs_plots(:,valid_outputs),...
              plot_data,plot_data_SD],'FontSize', Legend_FontSize,...
              'Fontweight',Legend_Fontweight,'Location',...
              'layout',"Orientation","Horizontal");
          leg.Layout.Tile = 'South';
          leg.ItemTokenSize = Legend_ItemTokenSize;
          set(leg,'Box','off')
  
      end
  end
  end
  
  function [layout,input_plot,plots] = ...
      f_plot_in_out_left(rst,stg,sbtab,fig_number_same_exp,reuse,n,...
      plots,fig_number)
  % Function to plot input data on the left side of the figure
  
  % Set font settings for the plot
  f_set_font_settings()
  
  % Set figure names based on whether the same figure is reused or not
  if reuse
      name_short = "E " + (n-1) + " " + fig_number_same_exp;
      name_long = ...
          "Experiment " + (n-1) + " " + fig_number_same_exp + "  (E " +...
          (n-1) + " " + fig_number_same_exp +")";
  else
      name_short = "E " + (n-1);
      name_long = "Experiment " + (n-1) + "  (E " + (n-1) +")";
  end
  
  plots(fig_number,:) = f_renew_plot(name_short);
  
  % Create a tiled layout for the figure
  layout = tiledlayout(2,3,'Padding',"tight",'TileSpacing','tight');
  nexttile(layout,[2 1]);
  
  
  % Set title for the layout
  title(layout,name_long,...
      'FontSize', Major_title_FontSize,'Fontweight',Major_title_Fontweight)
  
  hold on
  
  % Plot input data for each experiment
  for o = 1:size(sbtab.datasets(n).input,2)
      for p = stg.pat
  
          % (Until a non broken simulation is found)
          if rst(p).simd{1,n} ~= 0
              input_species_ID =...
                  str2double(strrep(sbtab.datasets(n).input(o),'S',''))+1;
  
              % Plot the inputs to each experiment
              input_plot = ...
                  plot(rst(p).simd{1,n}.Time,rst(p).simd{1,n}.Data(1:end,...
                  input_species_ID),'DisplayName',...
                  string(rst(p).simd{1,n}.DataNames(input_species_ID)),...
                  'LineWidth',line_width);
  
              % Set ylabel with the correct units
              ylabel(string(rst(p).simd{1,n}. ...
                  DataInfo{input_species_ID,1}.Units), ...
                  'FontSize', Axis_FontSize,'Fontweight',Axis_Fontweight)
              break
          end
      end
  end
  
  % Set xlabel with correct font settings
  xlabel('Seconds','FontSize', Axis_FontSize,'Fontweight',Axis_Fontweight)
  ylim([0 inf])
  ytickformat('%-3.1f')
  
  % Add a title to the plot
  if size(sbtab.datasets(n).input,2) == 1
  [~,t4] = ...
      title("Input"," ",'FontSize', Minor_title_FontSize,...
      'Fontweight',Minor_title_Fontweight);
  else
  [~,t4] = ...
      title("Inputs"," ",'FontSize', Minor_title_FontSize,...
      'Fontweight',Minor_title_Fontweight);
  end
  t4.FontSize = Minor_Title_Spacing;
  
  hold off
  end
  

  
  

  Figure Sensitivity Analysis \(S_{i}\)

  

  Figure Sensitivity Analysis \(S_{Ti}\)

  

  Code figures SA

  function plots = f_plot_gsa_sensitivities(results,settings,sbtab)
  % This function creates plots for Global Sensitivity Analysis. It takes in
  % results from sensitivity analysis, settings, an SBtab table, and font
  % settings, then generates a set of plots for each section of the analysis.
  % The function relies on three helper functions to generate heatmap plots,
  % compute mean values, and set font settings. 
  % 
  % Inputs:
  % - results: A structure containing the results from the sensitivity
  %   analysis
  % - settings: A structure containing various settings for the analysis
  % - sbtab: An SBtab table used for creating the outputs
  % - font_settings: A structure containing the font settings for the plots
  %
  % Outputs:
  % - plots: A cell array containing the generated plots and their names
  %
  % Functions called:
  % - f_generate_plot: Generates a heatmap plot for the given parameters
  % - get_mean_values: Computes the mean values of an input matrix
  % - set_font_settings: Sets font settings according to the provided
  %   configuration
  % - f_renew_plot: Closes any existing figures with the specified name and
  % then creates a new figure with the given name and properties. It returns
  % a 1x2 cell array containing the figure name and the figure handle.
  %
  % Variables:
  % Loaded:
  % None
  %
  % Initialized:
  % - output_names2: Names of the outputs used in the plots
  % - par_names: Names of the parameters used in the plots
  % - par_names2: Modified names of the parameters used in the plots
  % - plot_sections: Information about each plot section, including name,
  % title, output_names2, and heatmap_values
  % 
  % Persistent:
  % None
  
  
  
  % Set font settings
  f_set_font_settings()
  
  % Get the total number of outputs
  [~,output_names.sd] = f_get_outputs(settings,sbtab);
  
  % Set output_names2 values
  for n = 1:size(output_names.sd,2)
      output_names.sd{n}{:} = strrep(output_names.sd{n}{:},"_","\_");
  end
  for n = settings.exprun
      output_names.se{n} = "E " + string(n-1);
  end
  output_names.xfinal = output_names.sd;
  
  % Set parameter names
  % par_names = cell(1,settings.parnum);
  par_names2 = cell(1,settings.parnum);
  par_names = "P_{" + [1:settings.parnum] + "}";
  for n = 1:settings.parnum
      % par_names = n
      % par_names{n} = char("P_{" + find(settings.partest==n) + "}");
      par_names2{n} = string(par_names{n}(1,:));
      % Confirm if can be deleted
      % for m = 2:size(par_names{n},1)
      %     par_names2{n} = string(par_names2{n}) + ", " +...
      %         string(par_names{n}(m,:));
      % end
  end
  
  % Define plot sections
  plot_sections = {
      % Bootstrapping quartile mean of first order Sensitivity index for
      % score per Experimental Output
      "Si seo bm", ...
      ["First order Sensitivities",...
      "calculated using the Score of each Experimental Output",...
      "(Bootstrapping Mean)"],...
      "output_names.sd", "get_mean_values(results.SiQ.sd,settings)";
      % Bootstrapping quartile mean of total order Sensitivity index for
      % score per Experimental Output
      "SiT seo bm",...
      ["Total order Sensitivities",...
      " calculated using the Score of each Experimental Output ",...
      " (Bootstrapping Mean)"],...
      "output_names.sd", "get_mean_values(results.SiTQ.sd,settings)";
      % Bootstrapping quartile mean of first order Sensitivity index for
      % score per Experiments
      "Si se bm",...
      ["First order Sensitivities",...
      " calculated using the Score of each Experiment",...
      "(Bootstrapping Mean)"],...
      "output_names.se", "get_mean_values(results.SiQ.se,settings)";
      % Bootstrapping quartile mean of total order Sensitivity index for
      % score per Experiments
      "SiT se bm",...
      ["Total order Sensitivities",...
      " calculated using the Score of each Experiment",...
      "(Bootstrapping Mean)"],...
      "output_names.se", "get_mean_values(results.SiTQ.se,settings)";
      % Bootstrapping quartile mean of first order Sensitivity index for the
      % final points of the simulations for the output beeing measured
      "Si xfinal bm",...
      ["First order Sensitivities",...
      " calculated using the final value of each Experimental Output",...
      "(Bootstrapping Mean)"],...
      "output_names.xfinal", "get_mean_values(results.SiQ.xfinal,settings)"
      % Bootstrapping quartile mean of total order Sensitivity index for the
      % final points of the simulations for the output beeing measured
      "SiT xfinal bm",...
      ["Total order Sensitivities",...
      " calculated using the final value of each Experimental Output",...
      "(Bootstrapping Mean)"],...
      "output_names.xfinal", "get_mean_values(results.SiTQ.xfinal,settings)"
      };
  
  % Generate plots for each section
  for i = 1:size(plot_sections, 1)
      [plots(i,:)] = f_generate_plot(results, settings, output_names,...
          par_names2, plot_sections{i, 1}, plot_sections{i, 2},...
          plot_sections{i, 3}, plot_sections{i, 4});
  end
  
  % Create Si, SiT plot
  plots(7,:) = f_renew_plot('Si,SiT');
  
  layout = tiledlayout(1,1,'Padding','compact','TileSpacing','tight');
  nexttile(layout)
  
  for n = 1:size(par_names2,2)
      a{n} = char(par_names2{n});
  end
  
  a = categorical(a,a);
  
  bar(a,[transpose(results.Si.st(:,1:settings.parnum)),...
      transpose(results.SiT.st(:,1:settings.parnum))])
  set(gca,'FontSize', Axis_FontSize);
  xlabel('Parameters','FontSize', Axis_FontSize,...
      'Fontweight',Axis_Fontweight);
  ylabel('Sensitivity','FontSize', Axis_FontSize,...
      'Fontweight',Axis_Fontweight);
  title(layout,...
      'Sensitivities calculated using the sum of the Score of all Experiments',...
      'FontSize',Major_title_FontSize,'Fontweight',Major_title_Fontweight);
  leg = legend({'Si','SiT'},'Location','best',...
      'FontSize', Legend_FontSize,'Fontweight',Legend_Fontweight);
  leg.ItemTokenSize = Legend_ItemTokenSize;
  legend boxoff
  
  % Create Si, SiT bootstraping plot
  plots(8,:) = f_renew_plot('Si,SiT b');
  
  
  layout = tiledlayout(1,1,'Padding','compact','TileSpacing','tight');
  nexttile(layout)
  
  T = [];
  
  for n = 1:size(a,2)
      for m = 1:size(results.SiQ.st(:,n),1)
          T = [T;table(results.SiQ.st(m,n),a(n),"Si")];
      end
  end
  for n = 1:size(a,2)
      for m = 1:size(results.SiTQ.st(:,n),1)
          T = [T;table(results.SiTQ.st(m,n),a(n),"SiT")];
      end
  end
  
  boxchart(T.Var2,T.Var1,'GroupByColor',T.Var3,...
      'MarkerStyle','.','JitterOutliers','on')
  set(gca,'FontSize', Axis_FontSize);
  xlabel('Parameters','FontSize',...
      Axis_FontSize,'Fontweight',Axis_Fontweight);
  ylabel('Sensitivity','FontSize',...
      Axis_FontSize,'Fontweight',Axis_Fontweight);
  title(layout,...
      'Sensitivities calculated using the sum of the Score of all Experiments',...
      'FontSize',Major_title_FontSize,'Fontweight',Major_title_Fontweight);
      
  subtitle(layout,'(Bootstrapping)','FontSize', Major_subtitle_FontSize,...
      'Fontweight',Major_subtitle_Fontweight);
  leg = legend({'Si','SiT'},'Location','best',...
      'FontSize', Legend_FontSize,'Fontweight',Legend_Fontweight);
  leg.ItemTokenSize = Legend_ItemTokenSize;
  legend boxoff
  end
  
  function [plots] =...
      f_generate_plot(results,settings,output_names,par_names2,name,major_title,...
      output_names_2,heatmap_values)
  % Function to generate heatmap plot for the given parameters
  
  % Set font settings
  f_set_font_settings()
  
  plots = f_renew_plot(name);
  
  layout = tiledlayout(1,1,'Padding','compact','TileSpacing','tight');
  nexttile(layout)
  
  fixed_output_names2 = eval(output_names_2);
  fixed_output_names2 =...
      fixed_output_names2(~cellfun('isempty',fixed_output_names2));
  
  fixed_heatmap_values = eval(heatmap_values);
  fixed_heatmap_values =...
      fixed_heatmap_values(:,all(~isnan(fixed_heatmap_values)));
  
  h = heatmap(fixed_output_names2,par_names2,...
      fixed_heatmap_values,'Colormap',turbo,...
      'ColorLimits',[0 1],'GridVisible','off',FontSize=Axis_FontSize);
  h.CellLabelFormat = '%.2f';
  
  title(layout,major_title(1),'FontSize', Major_title_FontSize,...
      'Fontweight',Major_title_Fontweight);
  subtitle(layout,major_title(2:end),'FontSize', Major_subtitle_FontSize,...
      'Fontweight',Major_subtitle_Fontweight)
  
  h.XLabel = '\fontsize{8} \bf Outputs';
  h.YLabel = '\fontsize{8} \bf Parameters';
  end
  
  function mean_values = get_mean_values(input_matrix,settings)
  % Function to compute the mean values of the input matrix
  
  mean_values = transpose(reshape(mean(input_matrix(:,:,1:settings.parnum)),...
      [size(input_matrix,2),size(input_matrix,3)]));
  end
  

• Calls

• Loads - data.mat

f_get_subplot

Code

function [figure_number,layout,plots] =...
    f_get_subplot(plot_total_n,plot_n,figure_number,fig_name,layout,plots)
% Determines the layout for subplots, creates a new figure when needed, and
% closes previous instances of the figure.
% 
% Inputs:
% - plot_total_n: Total number of plots to display
% - plot_n: Current plot number
% - figure_number: Current figure number
% - fig_name: Figure name as a string
% - layout: Layout object to be updated with new configuration
% - plots: Cell array containing figure handles and names
%
% Outputs:
% - figure_number: Updated figure number
% - layout: Updated layout object
% - plots: Updated cell array with figure handles and names
%
% Functions called:
% - create_new_figure: Closes any existing figure with the same name,
% then creates a new docked figure with the given name
% - calculate_layout: Calculates the layout for the current figure based
% on the figure number, total number of plots, maximum size, and subplot
% dimensions
% - f_renew_plot: Closes any existing figures with the specified name and
% then creates a new figure with the given name and properties. It returns
% a 1x2 cell array containing the figure name and the figure handle.
% 
% Variables:
% Loaded:
% None
%
% Initialized:
% - size_total: Maximum number of plots per figure
% - size_x: Array of subplot layout column counts
% - size_y: Array of subplot layout row counts
%
% Persistent:
% None

size_total = 12;

size_x = [1,1,1,2,3,3,4,4,3,4,4,4];
size_y = [1,2,3,2,2,2,2,2,3,3,3,3];

if mod(plot_n,size_total) == 0
    figure_number = figure_number + 1;
    % If the total number of plots exceeds the maximum per figure, create
    % additional figures and update the figure name.
    if plot_total_n > size_total
        fig_name = fig_name + " " + figure_number;
    end

    % Close previous instances of the figure and create a new one.
    plots = f_renew_plot(fig_name);

    % Calculate the layout for the current figure based on the total number
    % of plots, maximum size, and the dimensions of the subplot.
    layout =...
        calculate_layout(figure_number, plot_total_n,...
        size_total, size_x, size_y);
end
end

function layout = ...
    calculate_layout(figure_number, plot_total_n,...
    size_total, size_x, size_y)
% This function calculates the layout for the current figure based on the
% figure number, total number of plots, maximum size, and subplot
% dimensions.

if figure_number <= floor(plot_total_n/size_total)
    % If the current figure is not the last one, use the maximum size
    % dimensions for the layout.
    layout = tiledlayout(size_x(size_total), size_y(size_total),...
        'Padding', 'none', 'TileSpacing', 'tight');
else
    % If the current figure is the last one, calculate the remaining number
    % of plots and use the corresponding dimensions for the layout.
    remaining_plots =...
        plot_total_n - (floor(plot_total_n/size_total) * size_total);
    
    layout =...
        tiledlayout(size_x(remaining_plots), size_y(remaining_plots),...
        'Padding', 'none', 'TileSpacing', 'tight');
end
end

• Inputs

• Outputs

• Calls

• Loads