Setup and Import

f_load_settings

Code

function [stg,rst,sb] = f_user_input(mmf,analysis_options)

persistent last_SBtab_date
persistent last_model_folder
persistent last_settings_file_text
persistent last_settings_file_date
persistent last_analysis_text

Matlab_main_folder = mmf.main;

rst = [];
sb = [];
functions_cleared = false;

% Get the folder of the model
model_folder_general = Matlab_main_folder + "Model/";
last_choice = last_model_folder;
prompt = "What model folder should be used?\n";
[model_folder,last_model_folder] =...
    choose_options(model_folder_general,prompt,last_choice);

model_name_specific = string(model_folder);
folder_model_specific = model_folder_general + "/" + model_name_specific;

prompt = "\nWhat analysis should be performed?\n";
last_choice = last_analysis_text;
[analysis_text,last_analysis_text] =...
    parse_choices(prompt,analysis_options,last_choice);

% analysis_n = find(contains(analysis_options,analysis_text));
    
% Check if an analysis was chosen
if any(contains(analysis_options([1:3,6]),...
        analysis_text))
    
    %Get the Setting file to be used
    settings_folder = folder_model_specific + "/Matlab/Settings";
    last_choice = last_settings_file_text;
    prompt = "\nWhat file should be used as settings?\n";
    [settings_file_text,last_settings_file_text] =...
        choose_options(settings_folder,prompt,last_choice);
    
    settings_file = strrep(settings_file_text,".m","");
    
    % Add the default settings to the struct
    stg_add_default = eval("default_settings()");
    
    f = fieldnames(stg_add_default);
    for i = 1:length(f)
        stg.(f{i}) = stg_add_default.(f{i});
    end
    
    % Add chosen settings to the struct overwriting defaults when
    % appropriate
    [stg_add] = eval(settings_file + "()");
    
    f = fieldnames(stg_add);
    for i = 1:length(f)
        stg.(f{i}) = stg_add.(f{i});
    end
    
    % Check if the date of the settings file changed, if so clear functions
    listing = dir(settings_folder);
    for n = 1:size(listing,1)
        if matches(settings_file_text,listing(n).name,"IgnoreCase",true)
            settings_file_date = listing(n).date;
        end
    end
    
    [last_settings_file_date,functions_cleared] =...
        compare_last(settings_file_date,last_settings_file_date,...
        functions_cleared);
    
    % Check if the name of the settings file changed, if so clear functions
    [last_settings_file_text,functions_cleared] =...
        compare_last(settings_file_text,last_settings_file_text,...
        functions_cleared);
    
    % Check if the date of the SBtab changed, if so clear functions
    listing = dir(folder_model_specific);
    
    for n = 1:size(listing,1)
        if matches(stg.sbtab_excel_name,listing(n).name,"IgnoreCase",true)
            sbtab_date = listing(n).date;
        end
    end
    [last_SBtab_date,~] =...
        compare_last(sbtab_date,last_SBtab_date,functions_cleared);
    
    % Store the name of the chosen analysis in the settings struct
    stg.analysis = analysis_text;

    if contains(analysis_options(6),analysis_text)
        stg.import = true;
        stg.save_results = false;
        stg.plot = false;
    end
elseif any(contains(analysis_options(4:5),analysis_text))
    
    % Get the folder of the Analysis that should be reproduced
    folder_results = folder_model_specific + "/Matlab/Results";
    
    last_choice = [];
    prompt = "\nWhat analysis should be reproduced?\n";

    [r_analysis_text,~] =...
        choose_options(folder_results,prompt,last_choice);
    
    folder_results_specific = folder_results + "/" + ...
        r_analysis_text;
    
    last_choice = [];
    prompt = "\nWhen was this analysis run originaly?\n";
  
    [r_analysis_date_text,~] =...
        choose_options(folder_results_specific,prompt,last_choice);
    
    folder_results_specific_date = folder_results_specific + "/" + ...
        r_analysis_date_text;
    
    % Load the settings file and the SBtab struct
    load(folder_results_specific_date + "/Analysis.mat","stg","sb")
    
    % Set inport to false since we don't want to overwrite anything
    stg.import = false;
    
    % If the reproduction of an analysis is chosen clear the functions
    % because the settings most likely changed
    if contains(analysis_options(4),analysis_text)
        f_functions_to_clear()
    end
    
    % I the reproduction of the plots of an analyis is chosen make sure
    % we tell the code to produce plots and also load the results that were
    % previously obtained
    if contains(analysis_options(5),analysis_text)
        stg.plot = true;
        load(folder_results_specific_date + "/Analysis.mat","rst")
    end
end

% Set the chosen model folder in the settings struct
stg.folder_model = model_name_specific;
end

function [choice,last_choice] = choose_options(folder,prompt,last_choice)

listing = dir(folder);

for n = size(listing,1):-1:1
    if any(matches(listing(n).name,[".","..","Place models here.txt"]))
        listing(n)= [];
    end
end

for n = 1:size(listing,1)
    options(n) = string(listing(n).name);
end

[choice,last_choice] = parse_choices(prompt,options,last_choice);
end

function [choice,last_choice] = parse_choices(prompt,options,last_choice)

for n = 1:size(options,2)
    prompt = prompt + "\n" + n + ": " + options(n);
end

if ~isempty(last_choice)
    if any(contains(options,last_choice))
        prompt = prompt + "\n\nPress enter to use " + last_choice;
    else
        last_choice = [];
    end
end

prompt = prompt + "\n";

i = input(prompt);

if isempty(i)
    choice = [];
elseif i > 0 && i < size(options,2)+1
    choice = options(i);
    disp("The option chosen was: " + choice)
else
    prompt = "Please choose from the provided options";
    [choice,last_choice] = parse_choices(prompt,options,last_choice);
end

if isempty(choice)
    if ~isempty(last_choice)
        choice = last_choice;
        disp("The option chosen was: " + last_choice)
    else
        prompt = "Please choose from the provided options";
        [choice,last_choice] = parse_choices(prompt,options,last_choice);
    end
else
    last_choice = choice;
end
end

function [previous,f_cleared] = compare_last(current,previous,f_cleared)

if ~isempty(previous)
    if ~contains(current,previous)
        if f_cleared == false
            disp("Settings file changed, clearing functions")
            f_functions_to_clear()
            f_cleared = true;
        end
    end
end
previous = current;
end

It prompts the user to choose the model to run, the settings file to use, and the Analysis to perform.

• Outputs - stg, rst, sb, Analysis_n

f_import

Code

function [stg,sb] = f_import(stg,mmf)

Model_folder = mmf.model.main;

disp("Generating model files and folder from SBtab")

% Create needed folders
[~,~] = mkdir(mmf.model.data.main);
[~,~] = mkdir(mmf.model.input_functions.main);
[~,~] = mkdir(mmf.model.tsv.model_name);
[~,~] = mkdir(mmf.model.data.model_exp.main);

% Creates a .mat and a tsvs from the SBtab file
f_excel_sbtab_importer(mmf);

addpath(genpath(Model_folder));

% Creates a struct based on the SBtab that is used elswhere in the code and
% also adds the number of experiments and outputs to the settings struct
[stg,sb] = f_generate_sbtab_struct(stg,mmf);

%Create the model and input output structure from sbtab.mat

% Saves the model in .mat, .sbproj and .xml format, while also creating a
% file whith the data to run the model in all different experimental
% settings defined in the SBtab
f_sbtab_to_model(stg,sb,mmf)

% Creates code that loads the inputs of each experiment into a .mat file,
% and creates the code to read this inputs at runtime when the experiments
% are being simulated, all this generated code is stored on the Input
% functions folder
f_setup_input(stg,mmf)

%Creates three .mat files for each experiment, with all the added rules,
%species and parameters needed depending on the inputs and outputs
%specified on the SBtab, one for the equilibrium simulation run, one for
%the deffault run, and one for a more detailed run.
f_build_model_exp(stg,sb,mmf)
disp("Model files and folders generated successfully")
end

Creates the necessary folders inside the model folder. Calls subfunctions that convert the SBtab from an Excel into MATLAB® files useful for the workflow, TSVs and a SBML.

f_excel_sbtab_importer

Code

function f_excel_sbtab_importer(mmf)

Source_sbtab = mmf.model.sbtab;
Matlab_sbtab = mmf.model.data.sbtab;

% Get the total number of sheets in the SBTAB
sheets = sheetnames(Source_sbtab);

% Try to run the import the sheets in multicore, depending on the version
% of excel this migth not work
try
    parfor i = 1:size(sheets,1)
        sbtab_excel{i} = impexp (i,mmf);
    end
catch
    for i = 1:size(sheets,1)
        sbtab_excel{i} = impexp (i,mmf);
    end
end

% Save the SBTAB tables in .mat format
save(Matlab_sbtab,'sbtab_excel');
disp("SBtab with " + size(sheets,1) + " sheets parsed successfully")
end

function sbtab_excel = impexp (i,mmf)

Source_sbtab = mmf.model.sbtab;
tsv_name_folder = mmf.model.tsv.model_name;

% Import the SBTAB to a cell with a sheet per cell
sbtab_excel = readcell(Source_sbtab,'sheet',i);

% Replace "ismissing" values with empty spaces
mask = cellfun(@ismissing, sbtab_excel,'UniformOutput',false);
mask = cellfun(@min, mask);
mask = logical(mask);
sbtab_excel(mask) = {[]};

% Get name for tsv that is going to be exported
field = regexp(sbtab_excel{1,2},"TableName='[^']*'",'match');
field = string(replace(field,["TableName='","'"," "],["","","_"]));

%Export the tsv
cell_write_tsv(tsv_name_folder + field + ".tsv",sbtab_excel)
end

function cell_write_tsv(filename,origCell)

% save a new version of the cell for reference
modCell = origCell;
% assume some cells are numeric, in which case set to char
iNum = cellfun(@isnumeric,origCell);

% Replace numeric sells with cell strings
for n = 1:size(iNum,1)
    for m = 1:size(iNum,2)
        modCell(n,m) = cellstr(num2str(origCell{n,m}));
    end
end

%Save the file that only as strings in each cell
modCell = transpose(modCell);

[rNum,cNum] = size(origCell);
frmt = repmat([repmat('%s\t',1,cNum-1),'%s\n'],1,rNum);
fid = fopen(filename,'wt');
fprintf(fid,frmt,modCell{:});
fclose(fid);
end

Loads the information in the SBtab and creates a . mat file that contains the sbtab and TSVs corresponding to all the SBtab tabs.

• Inputs - stg

• Saves

  • .mat file containing the SBtab in the “Model/Data” folder

  • TSVs containing the SBtab in the “Model/tsv” folder

f_generate_sbtab_struct

Code

function [stg,sb] = f_generate_sbtab_struct(stg,mmf)

Matlab_sbtab = mmf.model.data.sbtab;

if isfile(Matlab_sbtab)
    
    load(Matlab_sbtab,'sbtab_excel');
    
    sb = f_get_sbtab_fields(sbtab_excel);
    
    stg.expn = size(sb.Experiments.ID,1);
    stg.outn = size(sb.Output.ID,1);
end
end

function sb = f_get_sbtab_fields(sbtab_excel)
for n = 1:size(sbtab_excel,2)
    
    if ~isempty(sbtab_excel{1,n}{1,2})
        
        field = regexp(sbtab_excel{1,n}{1,2},"TableName='[^']*'",'match');
        field = string(replace(field,["TableName='","'"," "],["","","_"]));
        
        for k = 1:size(sbtab_excel{1,n},2)
            
            if ~isempty(sbtab_excel{1,n}{2,k})
                subfield = sbtab_excel{1,n}{2,k};
                subfield =...
                    string(replace(subfield,["!",">",":"," "],["","","_","_"]));
                
                sb.(field).(subfield)(:,1) = sbtab_excel{1,n}(3:end,k)';
                
                sb.(field).(subfield) = sb.(field).(subfield)...
                    (~cellfun('isempty', sb.(field).(subfield)));
            end
        end
    end
end
end

Loads the SBtab saved in the .mat file and creates a MATLAB® struct that can be more easily parsed.

• Inputs - stg

• Outputs - sb, stg.expn, stg.outn.

f_sbtab_to_model

Code

function f_sbtab_to_model(stg,sb,mmf)
% Saves the model in .mat, .sbproj and .xml format, while also creating a
% file whith the data to run the model in all different experimental
% settings defined in the sbtab

modelobj = sbiomodel(stg.name);
compObj = [];

sbtab.species = cat(2,sb.Compound.Name,sb.Compound.InitialValue,...
    sb.Compound.IsConstant,sb.Compound.Unit,sb.Compound.Location);

sbtab.defpar = cat(2,sb.Parameter.Comment,sb.Parameter.Value_linspace,...
    sb.Parameter.Unit);

for n = 1:size(sb.Compartment.ID,2)
    compObj{n} = addcompartment(modelobj, sb.Compartment.Name{n});
    set(compObj{n}, 'CapacityUnits', sb.Compartment.Unit{n});
    set(compObj{n}, 'Value', sb.Compartment.Size{n});
end

for n = 1:size(sbtab.species,1)
    
    for m = 1:size(compObj,2)
        if string(compObj{m}.Name) == string(sb.Compound.Location{n})
            compartment_number_match = m;
        end
    end
    
    addspecies (compObj{compartment_number_match}, sb.Compound.Name{n},sb.Compound.InitialValue{n}...
        ,'InitialAmountUnits',sb.Compound.Unit{n});
end

for n = 1:size(sbtab.defpar,1)
    addparameter(modelobj,sb.Parameter.Name{n},...
        sb.Parameter.Value_linspace{n},'ValueUnits',sb.Parameter.Unit{n},'Notes',sb.Parameter.Comment{n});
end

for n = 1:size(sb.Reaction.ID,1)
    
    if ischar(sb.Reaction.IsReversible{n})
        if contains(convertCharsToStrings(sb.Reaction.IsReversible{n}),"true")
            reaction_name = strrep(sb.Reaction.ReactionFormula{n},'<=>',' <-> ');
        else
            reaction_name = strrep(sb.Reaction.ReactionFormula{n},'<=>',' -> ');
        end
    else
        if sb.Reaction.IsReversible{n}
            reaction_name = strrep(sb.Reaction.ReactionFormula{n},'<=>',' <-> ');
        else
            reaction_name = strrep(sb.Reaction.ReactionFormula{n},'<=>',' -> ');
        end
    end
    
    reaction_name_compartment = reaction_name;
    
    for m = 1:size(sb.Compound.Name,1)
        reaction_name_compartment =...
            insertBefore(string(reaction_name_compartment)," " +...
            string(sb.Compound.Name{m})," " + string(sb.Reaction.Location{n}));
    end
    
    while contains(reaction_name_compartment,...
            string(sb.Reaction.Location{n})+" "+string(sb.Reaction.Location{n}))
        reaction_name_compartment =...
            strrep(reaction_name_compartment,string(sb.Reaction.Location{n})+...
            " "+string(sb.Reaction.Location{n})," "+sb.Reaction.Location{n});
    end
    
    while contains(reaction_name_compartment,"  ")
        reaction_name_compartment = strrep(reaction_name_compartment,"  "," ");
    end
    
    reaction_name_compartment = strrep(reaction_name_compartment,...
        sb.Reaction.Location{n} + " ",sb.Reaction.Location{n}+".");
    reaction_name_compartment = string(sb.Reaction.Location{n})+"."+reaction_name_compartment;
    
    reactionObj = addreaction(modelobj,reaction_name_compartment);
    set(reactionObj,'ReactionRate',sb.Reaction.KineticLaw{n});
end

for n = 1:size(sb.Compound.ID,1)
    if ischar(sb.Compound.Assignment{n})
        if contains(convertCharsToStrings(sb.Compound.Assignment{n}),["true","True"])
            modelobj.species(n).BoundaryCondition = 1;
        end
    else
        if sb.Compound.Assignement{n} == 1
            modelobj.species(n).BoundaryCondition = 1;
        end
    end
    if ischar(sb.Compound.Interpolation{n})
        if contains(convertCharsToStrings(sb.Compound.Interpolation{n}),["true","True"])
            modelobj.species(n).BoundaryCondition = 1;
        end
    else
        if sb.Compound.Interpolation{n} == 1
            modelobj.species(n).BoundaryCondition = 1;
        end
    end
    if ischar(sb.Compound.IsConstant{n})
        if contains(convertCharsToStrings(sb.Compound.IsConstant{n}),["true","True"])
            modelobj.species(n).BoundaryCondition = 1;
        end
    else
        if sb.Compound.IsConstant{n} == 1
            modelobj.species(n).BoundaryCondition = 1;
        end
    end
end

sbtab.sim_time = [sb.Experiments.Sim_Time{:}];

species_INP_matcher ={};
for n = 1:size(sb.Compound.ID,1)
    if isfield(sb.Experiments,"S"+(n-1))
        species_INP_matcher{size(species_INP_matcher,1)+1,1} = n;
    end
end

for n = 1:size(sb.Experiments.ID,1)
    startamount = cell(1,size(species_INP_matcher,1));
    nstartamount = 0;
    nInputTime = 0;
    nInput = 0;
    nOutput = 0;

    for m = 1:size(sb.Compound.ID,1)
        if isfield(sb.Experiments,"S"+(m-1))
            nstartamount = nstartamount+1;
            startamount{nstartamount} = eval("sb.Experiments.S"+(m-1)+"(n)");
            startAmountName(nstartamount) = sb.Compound.Name(m);
        end
    end
    
    if isfield(sb.Experiments,"Normalize")
        sbtab.datasets(n).Normalize = sb.Experiments.Normalize{n};
    else
        sbtab.datasets(n).Normalize = [];
    end
    
    if isfield(eval(("sb.E")+(n-1)),"Time")
        Data(n).Experiment.t = transpose(eval("[sb.E"+(n-1)+".Time{:}]"));
    end
    
    for m = 1:size(sb.Compound.ID,1)
        if isfield(eval(("sb.E")+(n-1)+"I"),"Input_Time_S"+(m-1))
            nInputTime = nInputTime + 1;
            sbtab.datasets(n).input_time{1,nInputTime} = ...
                eval(("[sb.E") + (n-1) + "I.Input_Time_S" + (m-1) + "{:}]");
        end
        if isfield(eval(("sb.E")+(n-1)+"I"),"S"+(m-1))
            nInput = nInput + 1;
            sbtab.datasets(n).input_value{1,nInput} = ...
                eval(("[sb.E") + (n-1) + "I.S" + (m-1) + "{:}]");
            sbtab.datasets(n).input{nInput} = char("S" + (m-1));
        end
    end
    
    for m = 1:size(sb.Output.ID,1)
        if isfield(eval(("sb.E")+(n-1)),"Y"+(m-1))
            nOutput = nOutput+1;
            Data(n).Experiment.x(:,nOutput) = eval(("[sb.E") +...
                (n-1) + ".Y" + (m-1) + "{:}]");
            Data(n).Experiment.x_SD(:,nOutput) = eval(("[sb.E") +...
                (n-1) + ".SD_Y" + (m-1) + "{:}]");
            sbtab.datasets(n).output{nOutput} = sb.Output.Name(m);
            sbtab.datasets(n).output_value{nOutput} = ...
                {convertStringsToChars(...
                strrep(string(sb.Output.Location{m}) + "." +...
                string(sb.Output.Name{m}) + " = " +...
                string(sb.Output.Formula{m}),'eps','0.0001'))};
            sbtab.datasets(n).output_name{nOutput} = ...
                sb.Output.Name(m);
            sbtab.datasets(n).output_ID{nOutput} = ...
                sb.Output.ID(m);
            sbtab.datasets(n).output_location{nOutput} = ...
                sb.Output.Location(m);
        end
    end
    sbtab.datasets(n).stg.outnumber = nOutput;
    sbtab.datasets(n).start_amount = cat(2,startAmountName(:)...
        ,transpose([startamount{:}]),species_INP_matcher);
end

if isfield(sb,"Expression")
    for m = 1:size(sb.Expression.ID,1)
        if isfield(sb.Expression,'Formula')
            if isa(sb.Expression.Formula{m},'double')
                addspecies (modelobj, char(sb.Expression.Name(m)),...
                    str2double(string(sb.Expression.Formula{m})),...
                    'InitialAmountUnits',sb.Expression.Unit{m});
            else
                try
                    addspecies (modelobj, char(sb.Expression.Name(m)),0,...
                        'InitialAmountUnits',sb.Expression.Unit{m});
                catch
                end
                addrule(modelobj, char({convertStringsToChars(...
                    string(sb.Expression.Location{m}) + "." +...
                    string(sb.Expression.Name{m}) + " = " +...
                    string(sb.Expression.Formula{m}))}),...
                    'repeatedAssignment');
            end
        else
            addparameter(modelobj,char(sb.Expression.Name(m)),...
                str2double(string(sb.Expression.DefaultValue{m})),...
                'ValueUnits',sb.Expression.Unit{m});
        end
    end
end

if isfield(sb,"Input")
    for m = 1:size(sb.Input.ID,1)
        if isfield(sb.Input,'Formula')
            if isa(sb.Input.Formula{m},'double')
                addspecies (modelobj, char(sb.Input.Name(m)),...
                    str2double(string(sb.Input.DefaultValue{m})),...
                    'InitialAmountUnits',sb.Input.Unit{m});
            else
                try
                    addspecies (modelobj, char(sb.Input.Name(m)),0,...
                        'InitialAmountUnits',sb.Input.Unit{m});
                catch
                end
                addrule(modelobj, char({convertStringsToChars(...
                    string(sb.Input.Location{m}) + "." +...
                    string(sb.Input.Name{m}) + " = " +...
                    string(sb.Input.DefaultValue{m}))}),...
                    'repeatedAssignment');
            end
        else
            addparameter(modelobj,char(sb.Input.Name(m)),...
                str2double(string(sb.Input.DefaultValue{m})),...
                'ValueUnits',sb.Input.Unit{m});
        end
    end
end

if isfield(sb,"Constant")
    for m = 1:size(sb.Constant.ID,1)
        addparameter(modelobj,char(sb.Constant.Name(m)),...
            str2double(string(sb.Constant.Value{m})),...
            'ValueUnits',sb.Constant.Unit{m});
    end
end

sbproj_model = mmf.model.data.sbproj_model;
matlab_model = mmf.model.data.mat_model;
data_model = mmf.model.data.data_model; 
xml_model = mmf.model.data.xml_model; 

sbiosaveproject(sbproj_model,'modelobj')

save(matlab_model,'modelobj')

save(data_model,'Data','sbtab','sb')

sbmlexport(modelobj,xml_model)

end

Reads information from the SBtab and saves the model in MATLAB (.mat, .sbproj) and SBML(.xml) format, while also creating a file whith the data to run the model in all different experimental settings defined in the SBtab.

• Inputs - stg, sb

• Saves - model file .mat, model file .sbproj, model file .xml, and data file

f_setup_input

Code

function f_setup_input(stg,mmf)
% Creates code that loads the inputs of each experiment into a .mat file,
% and creates the code to read this inputs at runtime when the experiments
% are being simulated, all this generated code is stored on the
% Input_functions folder

matlab_model = mmf.model.data.mat_model;
data_model = mmf.model.data.data_model;
inp_model_data = mmf.model.data.input_model_data;
Model_folder = mmf.model.main;
model_input = mmf.model.input_functions.input;

%Find correct path for loading depending on the platform
load(data_model,'sbtab')

load(matlab_model,'modelobj');

for Exp_n = 1:size(sbtab.datasets,2)
    
    for index = 1:size(sbtab.datasets(Exp_n).input,2)
        if size(sbtab.datasets(Exp_n).input_value{index},2) > 100
            
            input_name = strrep(modelobj.species(1+str2double(strrep(...
                sbtab.datasets(Exp_n).input(index),'S',''))).name,".","");
            inpX = input_name + "X";
            inpT = input_name + "T";
            inph1 = input_name + "h1";
            inph2 = input_name + "h2";
            
            fullFileName = sprintf('%s.m',...
                model_input + Exp_n + "_" + input_name  );
            
            fileID = fopen(fullFileName, 'wt');

            inp_str = template1();
            inp_str = replace(inp_str,...
                ["SBtab_name","Exp_n","input_name",...
                "inpX", "inpT", "inph1", "inph2", "inp_model_data",...
                "sbtab.sim_time(Exp_n)"],[stg.name,Exp_n,...
                input_name, inpX, inpT, inph1,...
                inph2, inp_model_data,...
                sbtab.sim_time(Exp_n)]);

            fprintf(fileID,inp_str);
            fclose(fileID);
        end
    end
end

fullFileName = sprintf('%s.m',model_input + "_creator"  );

fileID = fopen(fullFileName, 'wt');
fprintf(fileID, "function " + stg.name + "_input_creator(~)\n");
helper = 0;
for Exp_n = 1:size(sbtab.datasets,2)
    for index =1:size(sbtab.datasets(Exp_n).input,2)
        if size(sbtab.datasets(Exp_n).input_value{index},2) > 100
            input_name = strrep(modelobj.species(1+str2double(strrep(...
                sbtab.datasets(Exp_n).input(index),'S',''))).name,".","");
            if helper == 0
                helper = 1;
                helper2 = Exp_n;
            end
            if index == 1 && Exp_n == helper2
                fprintf(fileID,"load('" + data_model + "','sbtab');\n");
                inp_creator_str = template2();
                inp_creator_str = replace(inp_creator_str,...
                    ["Exp_n", "input_name", "index", "inp_model_data"],...
                    [Exp_n, input_name, index, inp_model_data]);
                %                 fprintf(fileID,inp_creator_str);
            else
                inp_creator_str = template3();
                inp_creator_str = replace(inp_creator_str,...
                    ["Exp_n", "input_name", "index", "inp_model_data"],...
                    [Exp_n, input_name, index, inp_model_data]);
            end
            fprintf(fileID,inp_creator_str);
        end
    end
end
fprintf(fileID, "end\n");
fclose(fileID);

addpath(genpath(Model_folder));
eval(stg.name + "_input_creator()");
end

function inp_str = template1()
inp_str =...
    "function thisAmp = SBtab_name_inputExp_n_input_name(times)\n"+...
    "persistent inpX\n"+...
    "persistent inpT\n"+...
    "persistent inph1\n"+...
    "persistent inph2\n"+...
    "if isempty(inpX)\n"+...
        "Data = coder.load('inp_model_data','expExp_n_input_name');\n"+...
        "inpX = Data.expExp_n_input_name(:,2);\n"+...
        "inpT = Data.expExp_n_input_name(:,1);\n"+...
        "inph1 = 1;\n"+...
    "end\n"+...
    "thisAmp = inpX(end);\n"+...
    "if times ~= sbtab.sim_time(Exp_n)\n"+...
        "if times == 0\n"+...
            "inph1 = 1;\n"+...
            "thisAmp = inpX(1);\n"+...
            "else\n"+...
            "while times > inpT(inph1)\n"+...
            "inph1 = inph1 + 1;\n"+...
        "end\n"+...
        "while times < inpT(inph1-1)\n"+...
            "inph1  = inph1-1;\n"+...
            "end\n"+...
            "inph2 = (inpT(inph1)-times)*1/(inpT(inph1)-inpT(inph1-1));\n"+...
            "thisAmp = (inpX(inph1-1)*inph2 + inpX(inph1)*(1-inph2));\n"+...
        "end\n"+...
    "end\n"+...
    "end";
end


function inp_creator_str = template2()
inp_creator_str = ...
    "expExp_n_input_name(:,1) = sbtab.datasets(Exp_n).input_time{index};\n"+...
    "expExp_n_input_name(:,2) = sbtab.datasets(Exp_n).input_value{index};\n"+...
    "save('inp_model_data','expExp_n_input_name');\n";
end
function inp_creator_str = template3()
inp_creator_str = ...
    "expExp_n_input_name(:,1) = sbtab.datasets(Exp_n).input_time{index};\n"+...
    "expExp_n_input_name(:,2) = sbtab.datasets(Exp_n).input_value{index};\n"+...
    "save('inp_model_data','expExp_n_input_name','-append');\n";
end

Creates code that loads the inputs of each experiment into a .mat file and the code to read these inputs at runtime when the experiments are being simulated. All this generated code is stored on the “Model/«model folder name»/Formulas” folder.

• Inputs - stg

• Saves - model-specific functions

f_build_model_exp

Code

function f_build_model_exp(stg,sb,mmf)
%Creates two .mat files for each experiment, with all the added rules,
%species and parameters needed depending on the inputs and outputs
%specified on the sbtab, one for the equilibrium simulation run and one for
%the proper run

data_model = mmf.model.data.data_model;
mat_model = mmf.model.data.mat_model;
model_exp_eq = mmf.model.data.model_exp.equilibration;
model_exp_default = mmf.model.data.model_exp.default;
model_exp_detail = mmf.model.data.model_exp.detail;

%Find correct path for loading depending on the platform
load(data_model,'Data','sbtab')
load(mat_model,'modelobj');

model_run = cell(size(sb.Experiments.ID,1),1);
configsetObj = cell(size(sb.Experiments.ID,1),1);

for number_exp = 1:size(sb.Experiments.ID,1)
    
    output_value = sbtab.datasets(number_exp).output_value;
    output = sbtab.datasets(number_exp).output;
    input_time = sbtab.datasets(number_exp).input_time;
    input_value = sbtab.datasets(number_exp).input_value;
    input_species = sbtab.datasets(number_exp).input;
    
    model_run{number_exp} = copyobj(modelobj);
    configsetObj{number_exp} = getconfigset(model_run{number_exp});
    
    set(configsetObj{number_exp}, 'MaximumWallClock', stg.maxt);
    set(configsetObj{number_exp}, 'StopTime', stg.eqt);
    set(configsetObj{number_exp}.CompileOptions,...
        'DimensionalAnalysis', stg.dimenanal);
    set(configsetObj{number_exp}.CompileOptions,...
        'UnitConversion', stg.UnitConversion);
    set(configsetObj{number_exp}.SolverOptions,...
        'AbsoluteToleranceScaling', stg.abstolscale);
    set(configsetObj{number_exp}.SolverOptions,...
        'RelativeTolerance', stg.reltol);
    set(configsetObj{number_exp}.SolverOptions,...
        'AbsoluteTolerance', stg.abstol);
    set(configsetObj{number_exp}.SolverOptions, 'OutputTimes', stg.eqt);
    set(configsetObj{number_exp}, 'TimeUnits', stg.simtime);
    set(configsetObj{number_exp}.SolverOptions,...
        'MaxStep', stg.maxstepeq);
    
    set(configsetObj{number_exp}.SolverOptions,...
        'AbsoluteToleranceStepSize', stg.abstolstepsize_eq);
    
    
    model_exp = model_run{number_exp};
    config_exp = configsetObj{number_exp};
    
    save(model_exp_eq + number_exp + ".mat",'model_exp','config_exp')
    
    sbiosaveproject(model_exp_eq + number_exp + ".sbproj",'model_exp')
    
    set(configsetObj{number_exp}, 'StopTime', sbtab.sim_time(number_exp));
    
    set(configsetObj{number_exp}.SolverOptions, 'OutputTimes',...
        Data(number_exp).Experiment.t);
    
    set(configsetObj{number_exp}.SolverOptions, 'MaxStep', stg.maxstep);
    
    for n = 1:size(output,2)
        
        m = 0;
        for k = 1:size(model_run{number_exp}.species,1)
            if model_run{number_exp}.species(k).name == string(output{1,n})
                model_run{number_exp}.species(k).BoundaryCondition = 1;
                m = 1;
            end
        end
        
        if m == 0
            addspecies (model_run{number_exp}.Compartments(1),...
                char(output{1,n}),0,...
                'InitialAmountUnits',sb.Output.Unit{n});
        end
        
        addrule(model_run{number_exp}, char(output_value{1,n}),...
            'repeatedAssignment');
    end
    
    for j = 1:size(input_species,2)
        
        input_indexcode = str2double(strrep(input_species(j),'S',''));
        input_name = string(model_run{number_exp}.species(1 +...
                input_indexcode).name);
        
        if size(input_time{j},2) < 100
            
            model_run{number_exp}.species(...
                1 + input_indexcode).BoundaryCondition = 1;
            for n = 1:size(input_time{j},2)
                if ~isnan(input_time{j}(n))
                    
                    addparameter(model_run{number_exp},char("time_event_t_" + j + "_" +  n),...
                        str2double(string(input_time{j}(n))),...
                        'ValueUnits',char(stg.simtime));
                    
                    addparameter(model_run{number_exp},char("time_event_r_" + j + "_" +  n),...
                        str2double(string(input_value{j}(n))),...
                        'ValueUnits',char(model_run{number_exp}.species(1 +...
                        input_indexcode).InitialAmountUnits));
                    
                    addevent(model_run{number_exp}, ...
                        char("time>=time_event_t_" + j + "_" +  n),...
                        cellstr(sbtab.datasets(number_exp).output_location{1} +...
                        "." + input_name + " = time_event_r_" + j + "_" +  n));

                end
            end
        else
            
            addrule(model_run{number_exp}, char(sbtab.datasets(...
                number_exp).output_location{1} + "." + input_name +...
                "=" + string(model_run{number_exp}.name)+ "_input" + ...
                number_exp + "_" + input_name + "(time)"), 'repeatedAssignment');
        end
    end
    
    model_exp = model_run{number_exp};
    config_exp = configsetObj{number_exp};
    
    save(model_exp_default + number_exp + ".mat",'model_exp','config_exp')

    sbiosaveproject(model_exp_default + number_exp + ".sbproj",'model_exp')
    
    set(configsetObj{number_exp}.SolverOptions,'OutputTimes', []);
    set(configsetObj{number_exp}.SolverOptions,'MaxStep', stg.maxstepdetail);
    
    model_exp = model_run{number_exp};
    config_exp = configsetObj{number_exp};
    
    save(model_exp_detail + number_exp + ".mat",'model_exp','config_exp')
    
end
end

Creates two .mat files for each experiment, one for the equilibrium simulation run and one for the proper simulation. These files have all the added rules, species and parameters needed depending on the inputs and outputs specified on the SBtab.

• Inputs - stg, sb

• Saves - Ready to run models