fix function expansion of differentials

Author: TorkelE

src/dsl.jl

@@ -305,10 +305,11 @@ function make_reaction_system(ex::Expr, name)
         union(syms_declared, sps_inferred), tiv; requiredec)
     ps_inferred = setdiff(ps_pre_inferred, vs_inferred, diffs_inferred)
     syms_inferred = union(sps_inferred, ps_inferred, vs_inferred, diffs_inferred)
+    all_syms = union(syms_declared, syms_inferred)
 
     # Read options not related to the declaration or inference of symbols.
     obsexpr, obs_eqs, obs_syms = read_observed_options(options, ivs,
-        union(sps_declared, vs_declared), union(syms_declared, syms_inferred); requiredec)
+        union(sps_declared, vs_declared), all_syms; requiredec)
     continuous_events_expr = read_events_option(options, :continuous_events)
     discrete_events_expr = read_events_option(options, :discrete_events)
     default_reaction_metadata = read_default_noise_scaling_option(options)
@@ -322,7 +323,7 @@ function make_reaction_system(ex::Expr, name)
     spsexpr, spsvar = scalarize_macro(spsexpr_init, "specs")
     vsexpr, vsvar = scalarize_macro(vsexpr_init, "vars")
     cmpsexpr, cmpsvar = scalarize_macro(cmpexpr_init, "comps")
-    rxsexprs = get_rxexprs(reactions, equations, union(diffs_declared, diffs_inferred))
+    rxsexprs = get_rxexprs(reactions, equations, all_syms)
 
     # Assemblies the full expression that declares all required symbolic variables, and
     # then the output `ReactionSystem`.
@@ -565,10 +566,10 @@ end
 
 # From the system reactions (as `DSLReaction`s) and equations (as expressions),
 # creates the expressions that evaluates to the reaction (+ equations) vector.
-function get_rxexprs(reactions, equations, diffsyms)
+function get_rxexprs(reactions, equations, all_syms)
     rxsexprs = :(Catalyst.CatalystEqType[])
     foreach(rx -> push!(rxsexprs.args, get_rxexpr(rx)), reactions)
-    foreach(eq -> push!(rxsexprs.args, escape_equation!(eq, diffsyms)), equations)
+    foreach(eq -> push!(rxsexprs.args, escape_equation!(eq, all_syms)), equations)
     return rxsexprs
 end
 
@@ -598,10 +599,12 @@ function get_rxexpr(rx::DSLReaction)
 end
 
 # Recursively escape functions within equations of an equation written using user-defined functions.
-# Does not expand special function calls like "hill(...)" and differential operators.
-function escape_equation!(eqexpr::Expr, diffsyms)
-    eqexpr.args[2] = recursive_escape_functions!(eqexpr.args[2], diffsyms)
-    eqexpr.args[3] = recursive_escape_functions!(eqexpr.args[3], diffsyms)
+# Does not escape special function calls like "hill(...)" and differential operators. Does
+# also not escape stuff corresponding to e.g. species or parameters (required for good error
+# for when e.g. a species is used as a differential, or for time delays in the future).
+function escape_equation!(eqexpr::Expr, all_syms)
+    eqexpr.args[2] = recursive_escape_functions!(eqexpr.args[2], all_syms)
+    eqexpr.args[3] = recursive_escape_functions!(eqexpr.args[3], all_syms)
     eqexpr
 end
 
@@ -934,9 +937,6 @@ function make_reaction(ex::Expr)
     reaction = get_reaction(ex)
     species, parameters = extract_sps_and_ps([reaction], [])
 
-    # Checks for input errors.
-    forbidden_symbol_check(union(species, parameters))
-
     # Creates expressions corresponding to code for declaring the parameters, species, and reaction.
     spexprs = get_usexpr(species, Dict{Symbol, Expr}())
     pexprs = get_psexpr(parameters, Dict{Symbol, Expr}())
@@ -964,11 +964,11 @@ end
 
 # Recursively traverses an expression and escapes all the user-defined functions.
 # Special function calls like "hill(...)" are not expanded.
-function recursive_escape_functions!(expr::ExprValues, diffsyms = [])
+function recursive_escape_functions!(expr::ExprValues, syms_skip = [])
     (typeof(expr) != Expr) && (return expr)
-    foreach(i -> expr.args[i] = recursive_escape_functions!(expr.args[i], diffsyms),
+    foreach(i -> expr.args[i] = recursive_escape_functions!(expr.args[i], syms_skip),
         1:length(expr.args))
-    if (expr.head == :call) && !isdefined(Catalyst, expr.args[1]) && expr.args[1] ∉ diffsyms
+    if (expr.head == :call) && !isdefined(Catalyst, expr.args[1]) && expr.args[1] ∉ syms_skip
         expr.args[1] = esc(expr.args[1])
     end
     expr

src/expression_utils.jl

@@ -22,15 +22,6 @@ function is_escaped_expr(expr)
     return (expr isa Expr) && (expr.head == :escape) && (length(expr.args) == 1)
 end
 
-### Parameters/Species/Variables Symbols Correctness Checking ###
-
-# Throws an error when a forbidden symbol is used.
-function forbidden_symbol_check(syms)
-    used_forbidden_syms = intersect(forbidden_symbols_error, syms)
-    isempty(used_forbidden_syms) ||
-        error("The following symbol(s) are used as species or parameters: $used_forbidden_syms, this is not permitted.")
-end
-
 ### Catalyst-specific Expressions Manipulation ###
 
 # Some options takes input on form that is either `@option ...` or `@option begin ... end`.

src/spatial_reaction_systems/spatial_reactions.jl

@@ -55,11 +55,13 @@ function make_transport_reaction(rateex, species)
     find_parameters_in_rate!(parameters, rateex)
 
     # Checks for input errors.
-    forbidden_symbol_check(union([species], parameters))
+    if isempty(intersect(forbidden_symbols_error, union([species], parameters)))
+        error("The following symbol(s) are used as species or parameters: $(intersect(forbidden_symbols_error, union([species], parameters)))), this is not permitted.")
+    end
 
     # Creates expressions corresponding to actual code from the internal DSL representation.
     sexprs = get_usexpr([species], Dict{Symbol, Expr}())
-    pexprs = get_pexpr(parameters, Dict{Symbol, Expr}())
+    pexprs = get_psexpr(parameters, Dict{Symbol, Expr}())
     iv = :($(DEFAULT_IV_SYM) = default_t())
     trxexpr = :(TransportReaction($rateex, $species))
 

test/runtests.jl

@@ -15,19 +15,6 @@ end
 ### Run Tests ###
 @time begin
     if GROUP == "All" || GROUP == "Core"
-        # Tests the `ReactionSystem` structure and its properties.
-        @time @safetestset "Reaction Structure" begin include("reactionsystem_core/reaction.jl") end
-        @time @safetestset "ReactionSystem Structure" begin include("reactionsystem_core/reactionsystem.jl") end
-        @time @safetestset "Higher Order Reactions" begin include("reactionsystem_core/higher_order_reactions.jl") end
-        @time @safetestset "Symbolic Stoichiometry" begin include("reactionsystem_core/symbolic_stoichiometry.jl") end
-        @time @safetestset "Parameter Type Designation" begin include("reactionsystem_core/parameter_type_designation.jl") end
-        @time @safetestset "Custom CRN Functions" begin include("reactionsystem_core/custom_crn_functions.jl") end
-        @time @safetestset "Coupled CRN/Equation Systems" begin include("reactionsystem_core/coupled_equation_crn_systems.jl") end
-        @time @safetestset "Events" begin include("reactionsystem_core/events.jl") end
-
-        # Tests model creation via the @reaction_network DSL.
-        @time @safetestset "DSL Basic Model Construction" begin include("dsl/dsl_basic_model_construction.jl") end
-        @time @safetestset "DSL Advanced Model Construction" begin include("dsl/dsl_advanced_model_construction.jl") end
         @time @safetestset "DSL Options" begin include("dsl/dsl_options.jl") end
 
         # Tests compositional and hierarchical modelling.