Minor bug fixes in SBML importer

src/Create_PEtab_model.jl

@@ -297,6 +297,8 @@ function addParameterForConditionSpecificInitialValues(modelStr::String,
         for rowValue in experimentalConditionsFile[Symbol(state)]
             if typeof(rowValue) <: Real
                 continue
+            elseif ismissing(rowValue)
+                continue
             elseif isNumber(rowValue) == true || string(rowValue) ∈ parameterNames
                 continue
             elseif rowValue ∈ parametersFile[:parameterId]

src/Process_PEtab_files/Observables/Common.jl

@@ -258,10 +258,16 @@ end
     Replace the explicit rule variable with the explicit rule
 """
 function replaceExplicitVariableWithRule(formula::String, SBMLDict::Dict)::String
-    for (key,value) in SBMLDict["modelRuleFunctions"]
-        formula = replaceWholeWord(formula, key, "(" * value[2] * ")")
+    _formula = deepcopy(formula)
+    while true
+        for (key, value) in SBMLDict["assignmentRulesStates"]
+            _formula = replaceWholeWord(_formula, key, "(" * value * ")")
+        end
+        _formula == formula && break
+        formula = deepcopy(_formula)
     end
-    return formula
+
+    return _formula
 end
 
 

src/Process_PEtab_files/Observables/Create_u0_h_sigma.jl

@@ -42,9 +42,9 @@ function create_σ_h_u0_File(modelName::String,
     hStr = create_h_Function(modelName, dirJulia, modelStateNames, parameterInfo, pODEProblemNames,
                              string.(θ_indices.θ_nonDynamicNames), observablesData, SBMLDict, writeToFile)
 
-    u0!Str = create_u0_Function(modelName, dirJulia, parameterInfo, pODEProblemNames, stateMap, writeToFile, inPlace=true)
+    u0!Str = create_u0_Function(modelName, dirJulia, parameterInfo, pODEProblemNames, stateMap, writeToFile, SBMLDict, inPlace=true)
 
-    u0Str = create_u0_Function(modelName, dirJulia, parameterInfo, pODEProblemNames, stateMap, writeToFile, inPlace=false)
+    u0Str = create_u0_Function(modelName, dirJulia, parameterInfo, pODEProblemNames, stateMap, writeToFile, SBMLDict, inPlace=false)
 
     σStr = create_σ_Function(modelName, dirJulia, parameterInfo, modelStateNames, pODEProblemNames, string.(θ_indices.θ_nonDynamicNames), observablesData, SBMLDict, writeToFile)
 
@@ -178,7 +178,8 @@ end
                        dirModel::String,
                        parameterInfo::ParametersInfo,
                        pODEProblemNames::Vector{String},
-                       stateMap;
+                       stateMap, 
+                       SBMLDict;
                        inPlace::Bool=true)
 
     For modelName create a function for computing initial value by translating the stateMap
@@ -192,7 +193,8 @@ function create_u0_Function(modelName::String,
                             parameterInfo::ParametersInfo,
                             pODEProblemNames::Vector{String},
                             stateMap,
-                            writeToFile::Bool;
+                            writeToFile::Bool, 
+                            SBMLDict;
                             inPlace::Bool=true)
 
     pathSave = joinpath(dirModel, modelName * "_h_sd_u0.jl")                            
@@ -216,9 +218,10 @@ function create_u0_Function(modelName::String,
     write(io, "\tt = 0.0 # u at time zero\n\n")
 
     # Write the formula for each initial condition to file
-    modelStateNames = [replace.(string.(stateMap[i].first), "(t)" => "") for i in eachindex(stateMap)]
+    _modelStateNames = [replace.(string.(stateMap[i].first), "(t)" => "") for i in eachindex(stateMap)]
+    modelStateNames = filter(x -> x ∉ string.(keys(SBMLDict["assignmentRulesStates"])), _modelStateNames)
     modelStateStr = ""
-    for i in eachindex(stateMap)
+    for i in eachindex(modelStateNames)
         stateName = modelStateNames[i]
         _stateExpression = replace(string(stateMap[i].second), " " => "")
         stateFormula = petabFormulaToJulia(_stateExpression, modelStateNames, parameterInfo, pODEProblemNames, String[])

src/SBML/Process_rules.jl

@@ -39,10 +39,10 @@ function processAssignmentRule!(modelDict::Dict, ruleFormula::String, ruleVariab
 
     if ruleVariable in keys(modelDict["states"])
         modelDict["assignmentRulesStates"][ruleVariable] = ruleFormula
-        return 
+        # Delete from state dictionary (as we no longer should assign an initial value to the state)
+        delete!(modelDict["states"], ruleVariable)
     end
 
-    modelDict["parameters"][ruleVariable] = ruleFormula
     return 
 end
 

src/SBML/SBML_to_ModellingToolkit.jl

@@ -410,7 +410,9 @@ function buildODEModelDictionary(modelSBML, ifElseToEvent::Bool)
     for (state, formula) in modelDict["assignmentRulesStates"]
         modelDict["derivatives"][state] = state * " ~ " * formula
         if state ∈ nonConstantParameterNames
-            modelDict["states"][state] = formula
+            delete!(modelDict["states"], state)
+            delete!(modelDict["parameters"], state)
+            nonConstantParameterNames = filter(x -> x != state, nonConstantParameterNames)
         end
     end
 
@@ -581,14 +583,17 @@ function createODEModelFunction(modelDict, pathJlFile, modelName, juliaFile, wri
         for key in keys(modelDict["states"])
             stringDict["variables"] *= key * "(t) "
         end
+        for (key, value) in modelDict["assignmentRulesStates"]
+            stringDict["variables"] *= key * "(t) "
+        end
 
-        for (index, key) in enumerate(keys(modelDict["states"]))
-            if index < length(modelDict["states"])
-                stringDict["stateArray"] *= key * ", "
-            else
-                stringDict["stateArray"] *= key * "]"
-            end
+        for (key, value) in modelDict["states"]
+            stringDict["stateArray"] *= key * ", "
+        end
+        for (key, value) in modelDict["assignmentRulesStates"]
+            stringDict["stateArray"] *= key * ", "
         end
+        stringDict["stateArray"] = stringDict["stateArray"][1:end-2] * "]"
 
         if length(modelDict["nonConstantParameters"]) > 0
             stringDict["variableParameters"] = "    ModelingToolkit.@variables"
@@ -661,6 +666,9 @@ function createODEModelFunction(modelDict, pathJlFile, modelName, juliaFile, wri
         for key in keys(modelDict["algebraicRules"])
             stringDict["derivatives"] *= ",\n    " * modelDict["algebraicRules"][key]
         end
+        for key in keys(modelDict["assignmentRulesStates"])
+            stringDict["derivatives"] *= ",\n    " * key * " ~ " * modelDict["assignmentRulesStates"][key]
+        end
         stringDict["derivatives"] *= "\n"
         stringDict["derivatives"] *= "    ]"
 
@@ -696,6 +704,10 @@ function createODEModelFunction(modelDict, pathJlFile, modelName, juliaFile, wri
             assignString = ",\n    " * key * " => " * value
             stringDict["initialSpeciesValues"] *= assignString
         end
+        for (key, value) in modelDict["assignmentRulesStates"]
+            assignString = ",\n    " * key * " => " * value
+            stringDict["initialSpeciesValues"] *= assignString
+        end
         stringDict["initialSpeciesValues"] *= "\n"
         stringDict["initialSpeciesValues"] *= "    ]"