Simulation and Scoring

f_sim_score

Code

function [score,rst,rst_not_simd] = f_sim_score(parameters, stg, model_folders)
% This function calculates the total score of a given model by simulating
% its performance and scoring the results.
%
% Inputs:
% - parameters: A double containing the model's parameters necessary for
% the simulation.
% - stg: A structure containing the settings and configurations for the
% simulation and scoring process.
% - model_folders: A structure containing the paths to the folders where
% the model and other relevant files are stored.
%
% Outputs:
% - score: A scalar value representing the total score of the model's
% performance.
% - rst: A structure containing the results of the simulation and scoring
% process.
% - rst_not_simd: A structure containing the results of the simulation and
% scoring process with the 'simd' field removed.
%
% Used Functions:
% - f_prep_sim: Simulates the model using the provided parameters,
% settings, and model folders.
% - f_score: Calculates the score of the model based on the results of the
% simulation.
%
% Variables:
% Loaded:
% - None.
%
% Initialized:
% - None.
%
% Persistent:
% - None.
%

%Turn off Dimension analysis warning from simbiology
warning('off','SimBiology:DimAnalysisNotDone_MatlabFcn_Dimensionless')

% Call the function that simulates the model
rst = f_prep_sim(parameters, stg, model_folders);

% Call the function that scores
rst = f_score(rst, stg, model_folders);

% Get the total score explicitly for optimization functions
score = rst.st;

rst_not_simd = rmfield( rst , 'simd');
end

This function, f_sim_score, calculates the total score of a given model by simulating the model and scoring its performance. The function takes three input arguments: parameters, stg, and model_folders. The output of the function includes the total score (score), the result of the simulation and scoring (rst), and the result of the simulation and scoring without the ‘simd’ field (rst_not_simd).

• Inputs

  • stg - Structure containing the settings and configurations for the simulation and scoring process.

  • parameters - Double containing the model’s parameters that are necessary for the simulation.

  • model_folders: Structure containing the paths to the folders where the model and other relevant files are stored.

• Outputs

  • score - rst.st Scalar value representing the total score of the model’s performance.

  • rst - rst.simd, rst.xfinal, rst.sd, rst.se, and rst.st Structure containing the results of the simulation and scoring process.

  • rst_not_simd - rst.xfinal, rst.sd, rst.se, and rst.st Structure containing the results of the simulation and scoring process with the ‘simd’ field removed.

• Calls

  • f_prep_sim This function simulates the model using the provided parameters, settings, and model folders.

  • f_score This function calculates the score of the model based on the results of the simulation.

f_prep_sim

Code

function result = f_prep_sim(parameters,stg,model_folders)
% This function prepares the parameters for a simulation by setting them
% to the default values defined in the SBTAB and then updating any
% parameters that are being tested. The parameters are also adjusted
% according to any thermodynamic constraints.
%
% Inputs:
% - parameters: Array of parameter values that need to be tested
% - stg: Settings structure containing various settings for the simulation
% - model_folders: Structure containing folder paths for the model data
%
% Outputs:
% - result: Structure containing simulation results and parameter values
%
% Used Functions:
% - update_simulation_parameters: Function to update simulation parameters
% - f_sim: Function to run the simulation
%
% Variables:
% Loaded:
% - Data: Array of structures containing experimental data
% - sbtab: SBTAB structure containing default parameters and species
% information
%
% Initialized:
% - sim_par: Array of simulation parameters
% - ssa: Array of species start amounts
%
% Persistent:
% - sbtab: SBTAB structure containing default parameters and species
% information
% - Data: Array of structures containing experimental data

% Save variables that need to be mantained over multiple function calls
persistent sbtab
persistent Data

data_model = model_folders.model.data.data_model;

% Import the data on the first run
if isempty(sbtab)
    load(data_model,'Data','sbtab')
end

% Set the parameters that are going to be used for the simulation to the
% default ones as definded in the SBTAB
sim_par(:,1) = [sbtab.defpar{:,2}];

% Check if the parametrer needs to be set to the value relevant for Profile
% Likelihood
if isfield(stg,"PLind") && isfield(stg,"PLval")
    parameters = [parameters(1:stg.PLind-1) stg.PLval parameters(stg.PLind:end)];
end

% Update simulation parameters
sim_par = update_simulation_parameters(sim_par, parameters, stg,sbtab);

%  Set the start amount for the species in the model to 0
ssa = zeros(size(sbtab.species,1),max(stg.exprun));

% Initialize the results variable
result = [];
result.parameters = sim_par;
result.simd{stg.exprun(1)} = [];

% Run simulations for each experiment
for n = stg.exprun
    
    % Try catch used because iterations errors can happen unexectedly and
    % we want to be able to continue simulations
try
    % Display progress message if appropriate
    if stg.simcsl
        disp("Running dataset number " + n + " of " + stg.exprun(end))
    end

    % Check if this is not the first experiment, the start values are
    % equal to the previous experiment, and the previous simulation
    % was valid
    is_not_first_experiment = n ~= stg.exprun(1);
    
    start_values_equal = min([sbtab.datasets(n).start_amount{:,2}] ==...
        [sbtab.datasets(stg.exprun(...
        max(find(stg.exprun==n)-1,1))).start_amount{:,2}]);
    previous_simulation_valid = ...
        result.simd{stg.exprun(max(find(stg.exprun==n)-1,1))} ~= 0;
    
    if is_not_first_experiment && start_values_equal && previous_simulation_valid
        % Set the start amounts based on the previous experiment
        ssa(:,n) = ssa(:,stg.exprun(find(stg.exprun==n)-1));
        if stg.simdetail
            ssa(:,n+2*stg.expn) = ssa(:,stg.exprun(find(stg.exprun==n)-1));
        end
    else
        % Set start amounts for species with non-zero values
        for j = 1:size(sbtab.datasets(n).start_amount,1)

            % Set the start amount of the species to the number defined in
            % the sbtab for each experiment
            ssa(sbtab.datasets(n).start_amount{j,3},n+stg.expn) =...
                sbtab.datasets(n).start_amount{j,2};
        end

        % Equilibrate the model
            result = f_sim(n+stg.expn,stg,sim_par,ssa,result,model_folders);

            % Update the start amounts based on equilibrium results
        for j = 1:size(sbtab.species,1)

            final_amount = result.simd{n+stg.expn}.Data(end,j);

            if final_amount < 1.0e-15
                ssa(j,n) = 0;
                if stg.simdetail
                    ssa(j,n+2*stg.expn) = 0;
                end
            else
                ssa(j,n) = final_amount;
                if stg.simdetail
                    ssa(j,n+2*stg.expn) = final_amount;
                end
            end
        end
    end
    % Run the main simulation
        result = f_sim(n,stg,sim_par,ssa,result,model_folders);
    % Run detailed simulation if required
        if stg.simdetail
            result = f_sim(n+2*stg.expn,stg,sim_par,ssa,result,model_folders);
        end

    % Check if the simulation output times match the SBTAB data times, if
    % they don't it means that the simulator didn't had enough time to run
    % the model (happens in some unfavorable configurations of parameters,
    % controlled by stg.maxt)
    simulation_times_match = size(Data(n).Experiment.t,1) == size(result.simd{n}.Data(:,end),1);

    % Handle cases where the simulation did not run properly
    if ~simulation_times_match
        result.simd{n} = 0;
    end

catch
result.simd{n} = 0;
end

end
end

function sim_par = update_simulation_parameters(sim_par, parameters, settings,sbtab)
% Iterate over all the parameters of the model
for n = 1:size(sim_par,1)

    % Update tested parameters
    if settings.partest(n) > 0
        sim_par(n) = 10.^(parameters(settings.partest(n,1)));
    end

    % Update thermodynamic constrained parameters
    if isfield(settings,'tci') && ~isempty(settings.tci) && ismember(n,settings.tci) && settings.partest(n) > 0
        sim_par = update_thermo_constrained_multiplications(sim_par, parameters,settings, n,sbtab);
        sim_par = update_thermo_constrained_divisions(sim_par, parameters, settings, n,sbtab);
    end
end
end

function sim_par = update_thermo_constrained_multiplications(sim_par, parameters, settings, n,sbtab)
% Iterate over the parameters that need to be mutiplied for calculating the
% parameter that depends on the thermodynamic constraints
for m = 1:size(settings.tcm, 2)
    % Check that the parameter that is going to be used to calculate the
    % parameter dependent on thermodynamic constraintsis is not the default
    if settings.partest(settings.tcm(n, m), 1) > 0
        % Check if the parametrer needs to be set to the value relevant for
        % Profile Likelihood
        if isfield(settings, "PLind") && settings.partest(settings.tcm(n, m), 1) == settings.PLind
            parameters(settings.partest(settings.tcm(n, m), 1)) = settings.PLval;
        end
        % Make the appropriate multiplications to get the thermodinamicly
        % constrained parameter
        sim_par(n) = sim_par(n) * (10 ^ (parameters(settings.partest(settings.tcm(n, m), 1))));
    else
        % Make the appropriate multiplications to get the thermodinamicly
        % constrained parameter
        sim_par(n) = sim_par(n) * (sbtab.defpar{settings.tcm(n, m), 2});
    end
end
end

function sim_par = update_thermo_constrained_divisions(sim_par, parameters, settings, n,sbtab)
% Iterate over the parameters that need to be divided for calculating the
% parameter that depends on the thermodynamic constraints
for m = 1:size(settings.tcd, 2)
    % Check that the parameter that is going to be used to calculate the
    % parameter dependent on thermodynamic constraintsis is not the default
    if settings.partest(settings.tcd(n, m), 1) > 0
        % Check if the parametrer needs to be set to the value relevant for
        % Profile Likelihood
        if isfield(settings, "PLind") && settings.partest(settings.tcd(n, m), 1) == settings.PLind
            parameters(settings.partest(settings.tcd(n, m), 1)) = settings.PLval;
        end
        % Make the appropriate divisions to get the thermodinamicly
        % constrained parameter
        sim_par(n) = sim_par(n) / (10 ^ (parameters(settings.partest(settings.tcd(n, m), 1))));
    else
        % Make the appropriate divisions to get the thermodinamicly
        % constrained parameter
        sim_par(n) = sim_par(n) / (sbtab.defpar{settings.tcd(n, m), 2});
    end
end
end

The code defines a main function f_prep_sim and three additional helper functions update_thermo_constrained_multiplications, update_thermo_constrained_divisions, and f_sim. The main function f_prep_sim prepares the parameters for a simulation, setting default values and updating any parameters being tested. It also adjusts the parameters according to thermodynamic constraints.

The main function f_prep_sim takes the following inputs:

• parameters: parameters for the simulation

• :ref:`stg<stg>`: settings for the simulation

• model_folders: folder paths for the models

And it outputs :

• rst: results of the simulation

The function initializes several persistent variables, imports data on the first run, and sets the default parameters for the simulation.

The function checks if the parameters need to be updated for Profile Likelihood.

It iterates through all model parameters, updating tested parameters and thermodynamic constrained parameters accordingly.

The function initializes the start amount for the species in the model to 0 and sets up a loop for each experiment being run.

Within the loop, the function tries to simulate the model, performing several checks and updates. If an error occurs during the simulation, the function catches the error and sets the simulation output to 0, indicating the simulation did not work properly.

The helper functions update_thermo_constrained_multiplications and update_thermo_constrained_divisions update the parameters according to the thermodynamic constraints. They iterate through parameters that need to be multiplied or divided, respectively, and make the appropriate adjustments.

The helper function f_sim runs simulations using SimBiology models for a set of experiments. It takes the following inputs:

• experiment_idx: indices of experiments to run

• settings: simulation settings

• simulation_parameters: parameter values for simulations

• species_start_amount: start amounts for species in simulations

• results: output variable to save simulation results

• main_model_folders: paths for model files

It outputs:

• results: simulation results

The function f_sim maintains the state of the loaded models between calls using persistent variables, loads the appropriate models, compiles the code for the simulation run, substitutes the start amounts of species and parameter values based on real-time results, and runs the simulation.

The simulation results are saved in the output variable, and the function can be called multiple times for different experiments. The function checks if the times of the simulation output and the simulation data from SBTAB match. If they do not match, it sets the simulation output to 0, indicating that the simulation did not work properly.

In summary, the main function f_prep_sim prepares the parameters for a simulation by setting them to the default values and then updating any parameters being tested. It adjusts the parameters according to any thermodynamic constraints and iterates through all the experiments to be run. The function then calls the helper function f_sim to run the simulation using SimBiology models for the set of experiments. The simulation results are saved in the output variable, and any errors encountered during the simulation are caught and handled appropriately.

f_sim

Code

function results = f_sim(experiment_idx,settings,simulation_parameters,...
    species_start_amount,results,main_model_folders)
% This function runs simulations using SimBiology models for a set of
% experiments. It loads the appropriate models and compiles the code for
% simulation run, then substitutes the start amounts of species and
% parameter values based on real-time results and runs the simulation. The
% results of the simulation are saved in the output variable. The function
% can be called multiple times for different experiments, and it maintains
% the state of the loaded models between calls using persistent variables.
%
% Inputs:
% - experiment_idx: Indices of experiments to run
% - settings: Simulation settings (e.g., sbioaccelerate, simdetail, expn,
% exprun)
% - simulation_parameters: Parameter values for simulations
% - species_start_amount: Start amounts for species in simulations
% - results: Output variable to save simulation results
% - main_model_folders: Paths for model files (e.g., model_exp_default,
% model_exp_eq, model_exp_detail)
%
% Outputs:
% - results: Simulation results (e.g., simd)
%
% Functions called:
% - sbioaccelerate: Compile model code for faster simulation run
% - sbiosimulate: Run simulation of SimBiology model with specified
% configuration
%
% Variables:
% Loaded:
% - model_exp: SimBiology model for each experiment
% - config_exp: SimBiology model configuration for each experiment
%
% Initialized:
% None
% 
% Persistent:
% - models: Cell array containing the SimBiology models for each experiment
% - configs: Cell array containing the configurations for each SimBiology
% model

% Save variables that need to be mantained over multiple function calls
persistent models
persistent configs

% If the function is called for the first time, load the appropriate model
% and compile the code for simulation run
if isempty(models)

    % Turn off warning messages
    warning('off','all')
    warning('off', 'SimBiology:InvalidSpeciesInitAmtUnits')
    warning('off', 'SimBiology:SolodeSolverIntegrationError');
    warning('off', 'SimBiology:Solver:IntegrationTolNotMet');
    warning('off', 'SimBiology:Solver:InfOrNaN');
    warning('off', 'SimBiology:solver');

    %Generate an empty array to be populated with the model suited for each
    %equilibration and experiment%
    models = cell(1,settings.expn*(2 + settings.simdetail));
    configs = cell(1,settings.expn*(2 + settings.simdetail));

    % Set the file paths for the different models
    model_exp_default = main_model_folders.model.data.model_exp.default;
    model_exp_eq = main_model_folders.model.data.model_exp.equilibration;
    model_exp_detail = main_model_folders.model.data.model_exp.detail;

    % Iterate over the experiments thar are being run
    for n = settings.exprun

        % Load and compile SimBiology models for each experiment

        % Load models for main simulation
        load(model_exp_default + n + ".mat",'model_exp','config_exp')
        models{n} = model_exp;
        configs{n} = config_exp;

        % Load models for equilibrium
        load(model_exp_eq + n + ".mat",'model_exp','config_exp')
        models{n+settings.expn} = model_exp;
        configs{n+settings.expn} = config_exp;

        % Load models for detailed simulation
        if settings.simdetail
            load(model_exp_detail + n + ".mat",'model_exp','config_exp')
            models{n+2*settings.expn} = model_exp;
            configs{n+2*settings.expn} = config_exp;
        end

        % Compile the model code if the option is selected in settings
        if settings.sbioacc
            sbioaccelerate(models{n},configs{n});
            sbioaccelerate(models{n+settings.expn},configs{n+settings.expn});
            if settings.simdetail
                sbioaccelerate(models{n+2*settings.expn},configs{n+2*settings.expn});
            end
        end
    end
end

% substitute the start amount of the species in the model with the correct
% ones for  simulations
set(models{experiment_idx}.species(1:size(species_start_amount(:,experiment_idx),1)),...
    {'InitialAmount'},num2cell(species_start_amount(:,experiment_idx)));

% Substitute the values of the parameters in the model for the correct one
% for simultaions
set(models{experiment_idx}.parameters(1:size(simulation_parameters,1)),...
    {'Value'},num2cell(simulation_parameters));

try
    %simulate the model using matlab built in function
    results.simd{experiment_idx} = sbiosimulate(models{experiment_idx},...
        configs{experiment_idx});
catch ME
    % disp(ME.identifier)

    % Set the simulation output to be 0, this is a non function
    % value that the score function expects in simulations that did
    % not worked properly
    results.simd{experiment_idx} = 0;
end

end

Description

Simulates the model with the provided configurations. The first time it is run it loads a representation of the model and the simulation, and compiles this information to C code.

Input Arguments

• exp_n - (double) Unique number to identify the model for each experiment or equilibrium reaction (it needs a new model object for each one)

• stg - stg.expn, stg.name, stg.sbioacc

• rt

  • rt.ssa - (double) steady state amounts

  • rt.par - (double) All parameters of the model, takes the default ones from SBtab and then replaces the ones being worked on.

• rst - rst.simd

Output Arguments

• rst - rst.simd

Functions called - Sbioaccelerate, Sbiosimulate Loaded variables - Ready to run model, Ready to run model equilibration

f_score

Code

function rst = f_score(rst, stg, mmf)
% This function calculates the score for a set of simulated results by
% comparing them to experimental data. It computes the score for each
% dataset and experiment and then calculates the total score based on the
% selected scoring strategy. The score serves as a metric for comparing the
% accuracy of different simulations or models.
%
% Inputs:
% - rst: Structure containing the simulation results and scores.
% - stg: Structure containing the settings for the scoring strategy, such
% as the option to use log10 scaling, error score, and other options.
% - mmf: Structure containing the model directory information.
%
% Outputs:
% - rst: Updated structure containing the calculated scores for each
% dataset, experiment, and the total score.
%
% Used Functions:
% - calculate_score_per_experiment: Calculates the score for each
% experiment.
% - calculate_score_per_dataset: Calculates the score for each dataset in
% an experiment.
% - f_normalize: Normalizes the simulation results for a dataset.
%
% Variables:
% Loaded:
% - Data: Experimental data.
% - sbtab: sbtab structure containing dataset information.
%
% Persistent:
% - sbtab: sbtab structure containing dataset information (persistent).
% - Data: Experimental data (persistent).

persistent sbtab
persistent Data

data_model = mmf.model.data.data_model;

% Import the data on the first run
if isempty(Data)
    load(data_model,'Data','sbtab')
end

% Iterate over the number of experiments
for n = stg.exprun
    rst = calculate_score_per_experiment(rst, stg, n, mmf,sbtab, Data);
end

% Calculate the total score
rst.st = sum(rst.se);

% Calculate the log10 of total score if option selected
if stg.useLog == 3
    rst.st = log10(rst.st);
end
end

function rst = calculate_score_per_experiment(rst, stg, n, mmf,sbtab, Data)

% Iterate over the number of datasets per experiment
for j = 1:size(sbtab.datasets(n).output, 2)
    rst = calculate_score_per_dataset(rst, stg, n, j, mmf, Data);
end

% Calculate score per experiment
rst.se(n, 1) = sum(rst.sd(:, n));

% Calculate the log10 of experiment score if option selected
if stg.useLog == 2
    rst.se(n, 1) = log10(rst.se(n, 1));
end
end

function rst = calculate_score_per_dataset(rst, stg, n, j, mmf, Data)

% Calculate score per dataset if there are no errors
if rst.simd{n} ~= 0
    data = Data(n).Experiment.x(:, j);
    data_sd = Data(n).Experiment.x_SD(:, j);


    % data = data /(max(data)-min(data));


    number_points = size(Data(n).Experiment.x(:, j), 1);
    sim_results = f_normalize(rst, stg, n, j, mmf);
    rst.xfinal{n, 1}(j) = sim_results(end);

    % Calculate score using formula that accounts for normalization
    % with the starting point of the result
    switch stg.useLog
        case {0, 2, 3}
            rst.sd(j, n) = sum(((data - sim_results) ./ (data_sd)).^2) / number_points;
        case 1
            rst.sd(j, n) = max(0, log10(sum(((data - sim_results) ./ (data_sd)).^2) / number_points));
        case 4
            rst.sd(j, n) = sum(((data - sim_results) ./ (data_sd * sqrt(number_points))).^2);
        otherwise
            error('Invalid value for stage.useLog: %d', stg.useLog);
    end

    % If there are errors output a very high score value (10^10)
elseif rst.simd{n} == 0 || rst.sd(n, j) == inf
    rst.sd(j, n) = stg.errorscore;
rst.xfinal{n, 1}(j) = 0;
end
end

Description

The f_score function computes the score for a given set of simulated results by comparing them with the experimental data. The function calculates the score for each dataset and experiment, and then computes the total score based on the selected scoring strategy. The score serves as a metric for comparing the accuracy of different simulations or models.

Input Arguments

• rst: Structure containing the simulation results and scores.

• stg: Structure containing the settings for the scoring strategy, such as the option to use log10 scaling, error score, and other options.

• mmf: Structure containing the model information, including the data model.

Output Arguments

• rst.st: Updated structure containing the calculated scores for each dataset, experiment, and the total score.

Example

% Define the input structures and settings
stg.useLog = 1;
stg.errorscore = 1e10;
stg.exprun = 1:3;
mmf.model.data.data_model = matlab model file
rst.simd = matlab output from f_prep_sim

% Call the f_score function
rst = f_score(rst, stg, mmf);

This example demonstrates how to call the f_score function with the input structures and settings. The function calculates the scores for the given simulation results based on the scoring strategy defined in the stg structure.

f_normalize

Code

function [sim_results_norm,sim_results_detailed,sim_results] = ...
f_normalize(results, settings, exp_number, output_number, model_folders)
% This function processes and normalizes simulation results based on a
% specified normalization method. It accepts a set of inputs, including the
% simulation results, settings, experiment and output numbers, and a model
% metafile structure. The function returns normalized simulation results,
% along with detailed normalized simulation results if the 'simdetail'
% setting is enabled.
%
% Inputs:
% - rst: Structure containing the simulation results and scores
% - stg: Structure containing the settings for the simulation
% - exp_number: An integer representing the experiment number
% - output_number: An integer representing the output number
% - mmf: Structure containing the model directory information
%
% Outputs:
% - sim_results: A matrix containing the normalized simulation results
% - sim_results_detailed: A matrix containing the detailed normalized
% simulation results (if stg.simdetail is true)
%
% Used Functions:
% - extract_data: Helper function to extract data from the simulation
% results
%
% Variables
% Persistent:
% - sbtab: SBtab structure
% - Data: Loaded data from the model
% - sb: Structure containing experiment IDs

persistent sbtab
persistent Data
persistent sb

% Load Data and sbtab if empty
if isempty(Data)
    load(model_folders.model.data.data_model, 'Data', 'sbtab','sb')
end

% Extract the data from the simulation results
sim_results = extract_data(results, exp_number, output_number, sbtab);
sim_results_detailed = [];

% Check if detailed simulation results are requested
if settings.simdetail
    sim_results_detailed =...
        extract_data(results, exp_number + 2 * settings.expn, ...
        output_number, sbtab);
end

% Get the normalization method
normalize = sbtab.datasets(exp_number).Normalize;
% exp_number
% normalize

% Perform normalization if a method is specified
if ~isempty(normalize)
    output_ID = sbtab.datasets(exp_number).output_ID{output_number}{:};
    norm_factor = extract_data(results, exp_number, output_number, sbtab);
%     output_ID
% contains(normalize, 'Max')
% contains(normalize, output_ID)

sim_results_norm = sim_results;

    % Normalize by the maximum value
    if contains(normalize, 'Max') && contains(normalize, output_ID)
        max_norm = max(norm_factor);
        sim_results_norm = sim_results / max_norm;
        if settings.simdetail
            sim_results_detailed = sim_results_detailed / max_norm;
        end
    end

    % normalize
    % contains(normalize, 'Norm')
    % output_ID
    % contains(normalize, output_ID)
    % Normalize to a value between 0 and 1
    if contains(normalize, 'Norm') && contains(normalize, output_ID)
        max_norm = max(norm_factor);
        min_norm = min(norm_factor);
        sim_results_norm = (sim_results-min_norm) / (max_norm-min_norm);
        if settings.simdetail
            sim_results_detailed = (sim_results_detailed-min_norm) / (max_norm-min_norm);
        end
    end


    % Normalize by the minimum value
    % if contains(normalize, 'Min') && contains(normalize, output_ID)
    % 
    %     min_norm = min(norm_factor);
    %     sim_results = sim_results / min_norm;
    %     min_norm
    %     if settings.simdetail
    %         sim_results_detailed = sim_results_detailed / min_norm;
    %     end
    % end

    % Normalize by time-dependent factors
    if contains(normalize, 'Time') && contains(normalize, output_ID)
        t_size = size(Data(exp_number).Experiment.t, 1);
        for n = 1:t_size
            exp_ID = getfield(sb, ['E' num2str(exp_number - 1) '.ID'], n);
            if contains(normalize, exp_ID)
                sim_results_norm = sim_results / norm_factor(n);
                if settings.simdetail
                    sim_results_detailed = ...
                    sim_results_detailed / norm_factor(n);
                end
            end
        end
    end
end
end

% Helper function to extract data
function data = extract_data(results, exp_number, output_number, sbtab)
% Helper function to extract data from the simulation results
% Input arguments:
% rst  - Structure containing the simulation results and scores.
% stg  - Structure containing the settings for the simulation.
% output_number - An integer representing the output number.
% sbtab - SBtab structure
% Output argument:
% data - extracted data from the simulation results
    data = results.simd{1, exp_number}.Data(:, end - ...
        size(sbtab.datasets(exp_number).output, 2) + output_number);
end

Description

The f_normalize function processes and normalizes simulation results based on a specified normalization method. It accepts a set of inputs, including the simulation results, settings, experiment and output numbers, and a model metafile structure. The function returns normalized simulation results, along with detailed normalized simulation results if the ‘simdetail’ setting is enabled.

Input Arguments

• rst: A structure containing the simulation results.

• stg: A structure containing the settings for the simulation.

• exp_number: An integer representing the experiment number.

• output_number: An integer representing the output number.

• mmf: A structure containing the model metafile information.

Output Arguments

• sim_results: A matrix containing the normalized simulation results.

• sim_results_detailed: A matrix containing the detailed normalized simulation results (if stg.simdetail is true).