save progress

Author: TorkelE

src/dsl.jl

@@ -221,7 +221,7 @@ struct DSLReaction
         subs = recursive_find_reactants!(sub_line, 1, Vector{DSLReactant}(undef, 0))
         prods = recursive_find_reactants!(prod_line, 1, Vector{DSLReactant}(undef, 0))
         metadata = extract_metadata(metadata_line)
-        new(sub, prod, rate, metadata, rx_line)
+        new(subs, prods, rate, metadata, rx_line)
     end
 end
 
@@ -232,13 +232,13 @@ end
 function recursive_find_reactants!(ex::ExprValues, mult::ExprValues,
         reactants::Vector{DSLReactant})
     # We have reached the end of the expression tree and can finalise and return the reactants.
-    if typeof(ex) != Expr || (ex.head == :escape) || (ex.head == :ref)
+    if (typeof(ex) != Expr) || (ex.head == :escape) || (ex.head == :ref)
         # The final bit of the expression is not a relevant reactant, no additions are required.
         (ex == 0 || in(ex, empty_set)) && (return reactants)
 
         # If the expression corresponds to a reactant on our list, increase its multiplicity.
-        if any(ex == reactant.reactant for reactant in reactants)
-            idx = findfirst(r.reactant == ex for r in reactants)
+        idx = findfirst(r.reactant == ex for r in reactants)
+        if !isnothing(idx)
             new_mult = processmult(+, mult, reactants[idx].stoichiometry)
             reactants[idx] = DSLReactant(ex, new_mult)
 
@@ -324,12 +324,13 @@ function make_reaction_system(ex::Expr, name)
 
     # Reads options (round 1, options which must be read before the reactions, e.g. because
     # they might declare parameters/species/variables).
+    requiredec = haskey(options, :require_declaration)
     compound_expr_init, compound_species = read_compound_options(options)
     species_declared = [extract_syms(options, :species); compound_species]
     parameters_declared = extract_syms(options, :parameters)
     variables_declared = extract_syms(options, :variables)
     vars_extracted, add_default_diff, equations = read_equations_options(options,
-        variables_declared)
+        variables_declared; requiredec)
 
     # Extracts all reactions. Extracts all parameters, species, and variables of the system and
     # creates lists with them.
@@ -338,31 +339,29 @@ function make_reaction_system(ex::Expr, name)
     syms_declared = Set(Iterators.flatten((parameters_declared, species_declared,
         variables)))
     species_extracted, parameters_extracted = extract_species_and_parameters(reactions,
-        syms_declared)
+        syms_declared; requiredec)
     species = vcat(species_declared, species_extracted)
     parameters = vcat(parameters_declared, parameters_extracted)
 
     # Reads options (round 2, options that either can, or must, be read after the reactions).
-    tiv, sivs, ivs, ivexpr = read_ivs_option(options)
+    tiv, sivs, ivs, ivsexpr = read_ivs_option(options)
     continuous_events_expr = read_events_option(options, :continuous_events)
     discrete_events_expr = read_events_option(options, :discrete_events)
-    observed_expr, observed_eqs, obs_syms = read_observed_options(options,
-        [species_declared; variables], ivs)
+    obsexpr, observed_eqs, obs_syms = read_observed_options(options,
+        [species_declared; variables], ivs; requiredec)
     diffexpr = create_differential_expr(options, add_default_diff,
         [species; parameters; variables], tiv)
     default_reaction_metadata = read_default_noise_scaling_option(options)
     combinatoric_ratelaws = read_combinatoric_ratelaws_option(options)
 
     # Checks for input errors.
-    if (sum(length, [reaction_lines, option_lines]) != length(ex.args))
-        error("@reaction_network input contain $(length(ex.args) - sum(length.([reaction_lines,option_lines]))) malformed lines.")
-    end
-    if any(!in(opt_in, option_keys) for opt_in in keys(options))
-        error("The following unsupported options were used: $(filter(opt_in->!in(opt_in,option_keys), keys(options)))")
-    end
     forbidden_symbol_check(union(species, parameters))
     forbidden_variable_check(variables)
     unique_symbol_check(vcat(species, parameters, variables, ivs))
+    (sum(length, [reaction_lines, option_lines]) != length(ex.args)) &&
+        error("@reaction_network input contain $(length(ex.args) - sum(length.([reaction_lines,option_lines]))) malformed lines.")
+    any(!in(option_keys), keys(options)) &&
+        error("The following unsupported options were used: $(filter(opt_in->!in(opt_in,option_keys), keys(options)))")
 
     # Creates expressions corresponding to actual code from the internal DSL representation.
     psexpr_init = get_pexpr(parameters_extracted, options)
@@ -371,35 +370,37 @@ function make_reaction_system(ex::Expr, name)
     psexpr, psvar = scalarize_macro(psexpr_init, "ps")
     spsexpr, spsvar = scalarize_macro(spsexpr_init, "specs")
     vsexpr, vsvar = scalarize_macro(vsexpr_init, "vars")
-    compound_expr, compsvar = scalarize_macro(compound_expr_init, "comps")
+    cmpsexpr, cmpsvar = scalarize_macro(compound_expr_init, "comps")
     rxsexprs = make_rxsexprs(reactions, equations)
 
     # Assemblies the full expression that declares all required symbolic variables, and
     # then the output `ReactionSystem`.
-    quote
+    MacroTools.flatten(striplines(quote
+        # Inserts the expressions which generates the `ReactionSystem` input.
+        $ivsexpr
         $psexpr
-        $ivexpr
         $spsexpr
         $vsexpr
-        $observed_expr
-        $compound_expr
+        $obsexpr
+        $cmpsexpr
         $diffexpr
 
-        sivs_vec = $sivs
-        rx_eq_vec = $rxexprs
-        vars = setdiff(union($spssym, $varssym, $compssym), $obs_syms)
-        obseqs = $observed_eqs
-        cevents = $continuous_events_expr
-        devents = $discrete_events_expr
+        # Stores each kwarg in a variable. Not necessary but useful when inspecting code for debugging.
+        name = $name
+        spatial_ivs = $sivs
+        rx_eq_vec = $rxsexprs
+        vars = setdiff(union($spsvar, $vsvar, $cmpsvar), $obs_syms)
+        observed = $observed_eqs
+        continuous_events = $continuous_events_expr
+        discrete_events = $discrete_events_expr
+        combinatoric_ratelaws = $combinatoric_ratelaws
+        default_reaction_metadata = $default_reaction_metadata
 
         remake_ReactionSystem_internal(
-            make_ReactionSystem_internal(
-                rx_eq_vec, $tiv, vars, $pssym;
-                name = $name, spatial_ivs = sivs_vec, observed = obseqs,
-                continuous_events = cevents, discrete_events = devents,
-                combinatoric_ratelaws = $combinatoric_ratelaws);
-            default_reaction_metadata = $default_reaction_metadata)
-    end
+            make_ReactionSystem_internal(rx_eq_vec, $tiv, vars, $psvar; name, spatial_ivs,
+                observed, continuous_events, discrete_events, combinatoric_ratelaws);
+            default_reaction_metadata)
+    end))
 end
 
 ### DSL Reaction Reading Functions ###
@@ -451,7 +452,7 @@ function read_reaction_line(line::Expr)
 
     # Handles metadata. If not provided, empty metadata is created.
     if length(line.args) == 2
-        in(arrow, double_arrows) ? :(([], [])) : :([])
+        metadata = in(arrow, double_arrows) ? :(([], [])) : :([])
     elseif length(line.args) == 3
         metadata = line.args[3]
     else
@@ -511,7 +512,7 @@ end
 
 # Function looping through all reactions, to find undeclared symbols (species or
 # parameters) and assign them to the right category.
-function extract_species_and_parameters(reactions, excluded_syms)
+function extract_species_and_parameters(reactions, excluded_syms; requiredec = false)
     # Loops through all reactant, extract undeclared ones as species.
     species = OrderedSet{Union{Symbol, Expr}}()
     for reaction in reactions
@@ -649,17 +650,17 @@ function read_ivs_option(options)
     # Creates the independent variables expressions (depends on whether the `ivs` option was used).
     if haskey(options, :ivs)
         ivs = Tuple(extract_syms(options, :ivs))
-        ivexpr = copy(options[:ivs])
-        ivexpr.args[1] = Symbol("@", "parameters")
+        ivsexpr = copy(options[:ivs])
+        ivsexpr.args[1] = Symbol("@", "parameters")
     else
         ivs = (DEFAULT_IV_SYM,)
-        ivexpr = :($(DEFAULT_IV_SYM) = default_t())
+        ivsexpr = :($(DEFAULT_IV_SYM) = default_t())
     end
 
     # Extracts the independet variables symbols (time and spatial), and returns the output.
     tiv = ivs[1]
     sivs = (length(ivs) > 1) ? Expr(:vect, ivs[2:end]...) : nothing
-    return tiv, sivs, ivs, ivexpr
+    return tiv, sivs, ivs, ivsexpr
 end
 
 # Returns the `default_reaction_metadata` output. Technically Catalyst's code could have been made
@@ -977,9 +978,8 @@ end
 # Reads a single line and creates the corresponding DSLReaction.
 function get_reaction(line)
     reaction = get_reactions([line])
-    if (length(reaction) != 1)
+    (length(reaction) != 1) &&
         error("Malformed reaction. @reaction macro only creates a single reaction. E.g. double arrows, such as `<-->` are not supported.")
-    end
     return only(reaction)
 end
 

src/expression_utils.jl

@@ -5,7 +5,7 @@ function esc_dollars!(ex)
     # If we do not have an expression: recursion has finished and we return the input.
     (ex isa Expr) || (return ex)
 
-    # If we have encountered an interpolation, perform the appropriate modification, else recur. 
+    # If we have encountered an interpolation, perform the appropriate modification, else recur.
     if ex.head == :$
         return esc(:($(ex.args[1])))
     else
@@ -26,27 +26,27 @@ end
 
 # Throws an error when a forbidden symbol is used.
 function forbidden_symbol_check(sym)
-    isempty(intersect(forbidden_symbols_error, sym)) && return
     used_forbidden_syms = intersect(forbidden_symbols_error, sym)
+    isempty(used_forbidden_syms) && return
     error("The following symbol(s) are used as species or parameters: $used_forbidden_syms, this is not permitted.")
 end
 
 # Throws an error when a forbidden variable is used (a forbidden symbol that is not `:t`).
 function forbidden_variable_check(sym)
-    isempty(intersect(forbidden_variables_error, sym)) && return
     used_forbidden_syms = intersect(forbidden_variables_error, sym)
+    isempty(used_forbidden_syms) && return
     error("The following symbol(s) are used as variables: $used_forbidden_syms, this is not permitted.")
 end
 
 # Checks that no symbol was sued for multiple purposes.
 function unique_symbol_check(syms)
-    allunique(syms) && return
-    error("Reaction network independent variables, parameters, species, and variables must all have distinct names, but a duplicate has been detected. ")
+    allunique(syms)||
+        error("Reaction network independent variables, parameters, species, and variables must all have distinct names, but a duplicate has been detected. ")
 end
 
 ### Catalyst-specific Expressions Manipulation ###
 
-# Some options takes input on form that is either `@option ...` or `@option begin ... end`. 
+# Some options takes input on form that is either `@option ...` or `@option begin ... end`.
 # This transforms input of the latter form to the former (with only one line in the `begin ... end` block)
 function option_block_form(expr)
     (expr.head == :block) && return expr
@@ -72,12 +72,12 @@ function find_varinfo_in_declaration(expr)
 
     # Case: X
     (expr isa Symbol) && (return expr, [], nothing, nothing)
-    # Case: X(t)         
+    # Case: X(t)
     (expr.head == :call) && (return expr.args[1], expr.args[2:end], nothing, nothing)
     if expr.head == :(=)
         # Case: X = 1.0
         (expr.args[1] isa Symbol) && (return expr.args[1], [], expr.args[2], nothing)
-        # Case: X(t) = 1.0        
+        # Case: X(t) = 1.0
         (expr.args[1].head == :call) &&
             (return expr.args[1].args[1], expr.args[1].args[2:end], expr.args[2].args[1],
             nothing)
@@ -114,7 +114,7 @@ end
 # (In this example the independent variable :t was inserted).
 # Here, the iv is a iv_expr, which can be anything, which is inserted
 function insert_independent_variable(expr_in, iv_expr)
-    # If expr is a symbol, just attach the iv. If not we have to create a new expr and mutate it. 
+    # If expr is a symbol, just attach the iv. If not we have to create a new expr and mutate it.
     # Because Symbols (a possible input) cannot be mutated, this function cannot mutate the input
     # (would have been easier if Expr input was guaranteed).
     (expr_in isa Symbol) && (return Expr(:call, expr_in, iv_expr))

test/dsl/dsl_advanced_model_construction.jl

@@ -123,17 +123,6 @@ let
     @test rn == rn2
 end
 
-# Creates a reaction network using `eval` and internal function.
-let
-    ex = quote
-        (Ka, Depot --> Central)
-        (CL / Vc, Central --> 0)
-    end
-    # Line number nodes aren't ignored so have to be manually removed
-    Base.remove_linenums!(ex)
-    @test eval(Catalyst.make_reaction_system(ex, QuoteNode(:name))) isa ReactionSystem
-end
-
 # Miscellaneous interpolation tests. Unsure what they do here (not related to DSL).
 let
     rx = @reaction k*h, A + 2*B --> 3*C + D
@@ -211,11 +200,11 @@ let
 end
 
 # Checks that repeated metadata throws errors.
-let 
-    @test_throws Exception @eval @reaction k, 0 --> X, [md1=1.0, md1=2.0] 
+let
+    @test_throws Exception @eval @reaction k, 0 --> X, [md1=1.0, md1=2.0]
     @test_throws Exception @eval @reaction_network begin
-        k, 0 --> X, [md1=1.0, md1=1.0] 
-    end 
+        k, 0 --> X, [md1=1.0, md1=1.0]
+    end
 end
 
 # Tests for nested metadata.
@@ -368,11 +357,11 @@ let
         @species (X(t))[1:2]
         (k[1],k[2]), X[1] <--> X[2]
     end
-    
+
     @parameters k[1:2]
     @species (X(t))[1:2]
     rx1 = Reaction(k[1], [X[1]], [X[2]])
     rx2 = Reaction(k[2], [X[2]], [X[1]])
     @named twostate = ReactionSystem([rx1, rx2], t)
     @test twostate == rn
-end
+end

test/dsl/dsl_options.jl

@@ -418,7 +418,7 @@ let
 end
 
 # Tests errors in `@variables` declarations.
-let 
+let
     # Variable used as species in reaction.
     @test_throws Exception @eval rn = @reaction_network begin
         @variables K(t)
@@ -813,7 +813,7 @@ let
     # Observable metadata provided twice.
     @test_throws Exception @eval @reaction_network begin
         @species X2 [description="Twice the amount of X"]
-        @observables (X2, [description="X times two."]) ~ 2X 
+        @observables (X2, [description="X times two."]) ~ 2X
         d, X --> 0
     end
 
@@ -998,6 +998,14 @@ let
     end
 end
 
+# Erroneous `@default_noise_scaling` declaration (other noise scaling tests are mostly in the SDE file).
+let
+    # Default noise scaling with multiple entries.
+    @test_throws Exception @eval @reaction_network begin
+        @default_noise_scaling η1 η2
+    end
+end
+
 ### Other DSL Option Tests ###
 
 # test combinatoric_ratelaws DSL option
@@ -1174,11 +1182,3 @@ let
         @observables X2 ~ X1
     end
 end
-
-# Erroneous `@default_noise_scaling` declaration (other noise scaling tests are mostly in the SDE file).
-let
-    # Default noise scaling with multiple entries.
-    @test_throws Exception @eval @reaction_network begin
-        @default_noise_scaling η1 η2
-    end 
-end