check all files round 1

Author: TorkelE

ext/CatalystBifurcationKitExtension/bifurcation_kit_extension.jl

@@ -26,6 +26,6 @@ function BK.BifurcationProblem(rs::ReactionSystem, u0_bif, ps, bif_par, args...;
     nsys = complete(nsys)
 
     # Makes BifurcationProblem (this call goes through the ModelingToolkit-based BifurcationKit extension).
-    return BK.BifurcationProblem(
-        nsys, u0_bif, ps, bif_par, args...; plot_var, record_from_solution, jac, kwargs...)
+    return BK.BifurcationProblem(nsys, u0_bif, ps, bif_par, args...; plot_var, 
+        record_from_solution, jac, kwargs...)
 end

ext/CatalystHomotopyContinuationExtension/homotopy_continuation_extension.jl

@@ -52,8 +52,8 @@ function steady_state_polynomial(rs::ReactionSystem, ps, u0)
     ns = complete(convert(NonlinearSystem, rs; remove_conserved = true))
     pre_varmap = [symmap_to_varmap(rs, u0)..., symmap_to_varmap(rs, ps)...]
     Catalyst.conservationlaw_errorcheck(rs, pre_varmap)
-    p_vals = ModelingToolkit.varmap_to_vars(
-        pre_varmap, parameters(ns); defaults = ModelingToolkit.defaults(ns))
+    p_vals = ModelingToolkit.varmap_to_vars(pre_varmap, parameters(ns); 
+        defaults = ModelingToolkit.defaults(ns))
     p_dict = Dict(parameters(ns) .=> p_vals)
     eqs_pars_funcs = vcat(equations(ns), conservedequations(rs))
     eqs = map(eq -> substitute(eq.rhs - eq.lhs, p_dict), eqs_pars_funcs)

ext/CatalystStructuralIdentifiabilityExtension/structural_identifiability_extension.jl

@@ -31,8 +31,8 @@ function Catalyst.make_si_ode(rs::ReactionSystem; measured_quantities = [], know
     # Creates a MTK ODESystem, and a list of measured quantities (there are equations).
     # Gives these to SI to create an SI ode model of its preferred form.
     osys, conseqs, _ = make_osys(rs; remove_conserved)
-    measured_quantities = make_measured_quantities(
-        rs, measured_quantities, known_p, conseqs; ignore_no_measured_warn)
+    measured_quantities = make_measured_quantities( rs, measured_quantities, known_p, conseqs;
+        ignore_no_measured_warn)
     return SI.mtk_to_si(osys, measured_quantities)[1]
 end
 
@@ -63,19 +63,18 @@ Notes:
 - This function is part of the StructuralIdentifiability.jl extension. StructuralIdentifiability.jl must be imported to access it.
 - `measured_quantities` and `known_p` input may also be symbolic (e.g. measured_quantities = [rs.X])
 """
-function SI.assess_local_identifiability(
-        rs::ReactionSystem, args...; measured_quantities = [],
-        known_p = [], funcs_to_check = Vector(), remove_conserved = true,
-        ignore_no_measured_warn = false, kwargs...)
+function SI.assess_local_identifiability(rs::ReactionSystem, args...;
+        measured_quantities = [], known_p = [], funcs_to_check = Vector(), 
+        remove_conserved = true, ignore_no_measured_warn = false, kwargs...)
     # Creates a ODESystem, list of measured quantities, and functions to check, of SI's preferred form.
     osys, conseqs, vars = make_osys(rs; remove_conserved)
-    measured_quantities = make_measured_quantities(
-        rs, measured_quantities, known_p, conseqs; ignore_no_measured_warn)
+    measured_quantities = make_measured_quantities( rs, measured_quantities, known_p, conseqs;
+        ignore_no_measured_warn)
     funcs_to_check = make_ftc(funcs_to_check, conseqs, vars)
 
     # Computes identifiability and converts it to a easy to read form.
-    out = SI.assess_local_identifiability(
-        osys, args...; measured_quantities, funcs_to_check, kwargs...)
+    out = SI.assess_local_identifiability( sys, args...; measured_quantities, 
+        funcs_to_check, kwargs...)
     return make_output(out, funcs_to_check, reverse.(conseqs))
 end
 
@@ -104,19 +103,18 @@ Notes:
 - This function is part of the StructuralIdentifiability.jl extension. StructuralIdentifiability.jl must be imported to access it.
 - `measured_quantities` and `known_p` input may also be symbolic (e.g. measured_quantities = [rs.X])
 """
-function SI.assess_identifiability(
-        rs::ReactionSystem, args...; measured_quantities = [], known_p = [],
-        funcs_to_check = Vector(), remove_conserved = true,
-        ignore_no_measured_warn = false, kwargs...)
+function SI.assess_identifiability( rs::ReactionSystem, args...; 
+        measured_quantities = [], known_p = [], funcs_to_check = Vector(), 
+        remove_conserved = true, ignore_no_measured_warn = false, kwargs...)
     # Creates a ODESystem, list of measured quantities, and functions to check, of SI's preferred form.
     osys, conseqs, vars = make_osys(rs; remove_conserved)
-    measured_quantities = make_measured_quantities(
-        rs, measured_quantities, known_p, conseqs; ignore_no_measured_warn)
+    measured_quantities = make_measured_quantities(rs, measured_quantities, known_p, conseqs; 
+        ignore_no_measured_warn)
     funcs_to_check = make_ftc(funcs_to_check, conseqs, vars)
 
     # Computes identifiability and converts it to a easy to read form.
-    out = SI.assess_identifiability(
-        osys, args...; measured_quantities, funcs_to_check, kwargs...)
+    out = SI.assess_identifiability(osys, args...; measured_quantities,
+        funcs_to_check, kwargs...)
     return make_output(out, funcs_to_check, reverse.(conseqs))
 end
 
@@ -145,10 +143,9 @@ Notes:
 - This function is part of the StructuralIdentifiability.jl extension. StructuralIdentifiability.jl must be imported to access it.
 - `measured_quantities` and `known_p` input may also be symbolic (e.g. measured_quantities = [rs.X])
 """
-function SI.find_identifiable_functions(
-        rs::ReactionSystem, args...; measured_quantities = [],
-        known_p = [], remove_conserved = true, ignore_no_measured_warn = false,
-        kwargs...)
+function SI.find_identifiable_functions(rs::ReactionSystem, args...; 
+        measured_quantities = [], known_p = [], remove_conserved = true, 
+        ignore_no_measured_warn = false, kwargs...)
     # Creates a ODESystem, and list of measured quantities, of SI's preferred form.
     osys, conseqs = make_osys(rs; remove_conserved)
     measured_quantities = make_measured_quantities(
@@ -166,8 +163,9 @@ end
 function make_osys(rs::ReactionSystem; remove_conserved = true)
     # Creates the ODESystem corresponding to the ReactionSystem (expanding functions and flattening it).
     # Creates a list of the systems all symbols (unknowns and parameters).
-    ModelingToolkit.iscomplete(rs) ||
+    if !ModelingToolkit.iscomplete(rs)
         error("Identifiability should only be computed for complete systems. A ReactionSystem can be marked as complete using the `complete` function.")
+    end
     rs = complete(Catalyst.expand_registered_functions(flatten(rs)))
     osys = complete(convert(ODESystem, rs; remove_conserved))
     vars = [unknowns(rs); parameters(rs)]

src/chemistry_functionality.jl

@@ -85,8 +85,8 @@ function make_compound(expr)
     # Loops through all components, add the component and the coefficients to the corresponding vectors
     # Cannot extract directly using e.g. "getfield.(composition, :reactant)" because then 
     # we get something like :([:C, :O]), rather than :([C, O]).
-    composition = Catalyst.recursive_find_reactants!(
-        expr.args[3], 1, Vector{ReactantStruct}(undef, 0))
+    composition = Catalyst.recursive_find_reactants!( xpr.args[3], 1, 
+        Vector{ReactantStruct}(undef, 0))
     components = :([])                                      # Becomes something like :([C, O]).                                         
     coefficients = :([])                                    # Becomes something like :([1, 2]). 
     for comp in composition
@@ -105,8 +105,8 @@ function make_compound(expr)
     isempty(ivs) && (species_expr = insert_independent_variable(species_expr, :(..)))
 
     # Expression which when evaluated gives a vector with all the ivs of the components.
-    ivs_get_expr = :(unique(reduce(
-        vcat, [arguments(ModelingToolkit.unwrap(comp)) for comp in $components])))
+    ivs_get_expr = :(unique(reduce(vcat, [arguments(ModelingToolkit.unwrap(comp))
+        for comp in $components])))
 
     # Creates the found expressions that will create the compound species.
     # The `Expr(:escape, :(...))` is required so that the expressions are evaluated in 
@@ -122,12 +122,12 @@ function make_compound(expr)
     species_declaration_expr = Expr(:escape, :(@species $species_expr))
     multiple_ivs_error_check_expr = Expr(:escape,
         :($(isempty(ivs)) && (length($ivs_get_expr) > 1) &&
-          error($COMPOUND_CREATION_ERROR_DEPENDENT_VAR_REQUIRED)))
+            error($COMPOUND_CREATION_ERROR_DEPENDENT_VAR_REQUIRED)))
     iv_designation_expr = Expr(:escape,
         :($(isempty(ivs)) && ($species_name = $(species_name)($(ivs_get_expr)...))))
     iv_check_expr = Expr(:escape,
         :(issetequal(arguments(ModelingToolkit.unwrap($species_name)), $ivs_get_expr) ||
-          error("The independent variable(S) provided to the compound ($(arguments(ModelingToolkit.unwrap($species_name)))), and those of its components ($($ivs_get_expr)))), are not identical.")))
+            error("The independent variable(S) provided to the compound ($(arguments(ModelingToolkit.unwrap($species_name)))), and those of its components ($($ivs_get_expr)))), are not identical.")))
     compound_designation_expr = Expr(:escape,
         :($species_name = ModelingToolkit.setmetadata(
             $species_name, Catalyst.CompoundSpecies, true)))
@@ -197,7 +197,7 @@ function make_compounds(expr)
 
     # The output needs to be converted to Vector{Num} (from  Vector{SymbolicUtils.BasicSymbolic{Real}}) to be consistent with e.g. @variables.
     compound_declarations.args[end] = :([ModelingToolkit.wrap(cmp)
-                                         for cmp in $(compound_declarations.args[end])])
+        for cmp in $(compound_declarations.args[end])])
 
     # Returns output that.
     return compound_declarations
@@ -264,8 +264,8 @@ function balance_reaction(reaction::Reaction)
         prodstoich = stoich[(length(reaction.substrates) + 1):end]
 
         # Create a new reaction with the balanced stoichiometries
-        balancedrx = Reaction(reaction.rate, reaction.substrates,
-            reaction.products, substoich, prodstoich)
+        balancedrx = Reaction(reaction.rate, reaction.substrates, reaction.products, 
+            substoich, prodstoich)
 
         # Add the reaction to the vector of all reactions
         balancedrxs[i] = balancedrx

src/dsl.jl

@@ -87,9 +87,7 @@ macro species(ex...)
     resize!(vars.args, idx + length(lastarg.args) + 1)
     for sym in lastarg.args
         vars.args[idx] = :($sym = ModelingToolkit.wrap(setmetadata(
-            ModelingToolkit.value($sym),
-            Catalyst.VariableSpecies,
-            true)))
+            ModelingToolkit.value($sym), Catalyst.VariableSpecies, true)))
         idx += 1
     end
 
@@ -419,11 +417,11 @@ function get_reactions(exprs::Vector{Expr}, reactions = Vector{ReactionStruct}(u
             push_reactions!(reactions, reaction.args[3], reaction.args[2],
                 rate.args[2], metadata.args[2], arrow)
         elseif in(arrow, fwd_arrows)
-            push_reactions!(
-                reactions, reaction.args[2], reaction.args[3], rate, metadata, arrow)
+            push_reactions!( reactions, reaction.args[2], reaction.args[3], 
+                rate, metadata, arrow)
         elseif in(arrow, bwd_arrows)
-            push_reactions!(
-                reactions, reaction.args[3], reaction.args[2], rate, metadata, arrow)
+            push_reactions!(reactions, reaction.args[3], reaction.args[2],
+                rate, metadata, arrow)
         else
             throw("Malformed reaction, invalid arrow type used in: $(MacroTools.striplines(line))")
         end
@@ -437,8 +435,9 @@ function read_reaction_line(line::Expr)
     # Special routine required for  the`-->` case, which creates different expression from all other cases.
     rate = line.args[1]
     reaction = line.args[2]
-    (reaction.head == :-->) &&
-        (reaction = Expr(:call, :→, reaction.args[1], reaction.args[2]))
+    if reaction.head == :-->
+        reaction = Expr(:call, :→, reaction.args[1], reaction.args[2])
+    end
     arrow = reaction.args[1]
 
     # Handles metadata. If not provided, empty metadata is created.
@@ -455,9 +454,8 @@ end
 
 # Takes a reaction line and creates reaction(s) from it and pushes those to the reaction array.
 # Used to create multiple reactions from, for instance, `k, (X,Y) --> 0`.
-function push_reactions!(
-        reactions::Vector{ReactionStruct}, sub_line::ExprValues, prod_line::ExprValues,
-        rate::ExprValues, metadata::ExprValues, arrow::Symbol)
+function push_reactions!(reactions::Vector{ReactionStruct}, sub_line::ExprValues,
+        prod_line::ExprValues, rate::ExprValues, metadata::ExprValues, arrow::Symbol)
     # The rates, substrates, products, and metadata may be in a tupple form (e.g. `k, (X,Y) --> 0`).
     # This finds the length of these tuples (or 1 if not in tuple forms). Errors if lengs inconsistent.
     lengs = (tup_leng(sub_line), tup_leng(prod_line), tup_leng(rate), tup_leng(metadata))
@@ -478,9 +476,8 @@ function push_reactions!(
             error("Some reaction metadata fields where repeated: $(metadata_entries)")
         end
 
-        push!(reactions,
-            ReactionStruct(get_tup_arg(sub_line, i), get_tup_arg(prod_line, i),
-                get_tup_arg(rate, i), metadata_i))
+        push!(reactions, ReactionStruct(get_tup_arg(sub_line, i), 
+            get_tup_arg(prod_line, i), get_tup_arg(rate, i), metadata_i))
     end
 end
 
@@ -630,8 +627,9 @@ end
 # Read the events (continious or discrete) provided as options to the DSL. Returns an expression which evalutes to these.
 function read_events_option(options, event_type::Symbol)
     # Prepares the events, if required to, converts them to block form.
-    (event_type in [:continuous_events, :discrete_events]) ||
+    if event_type ∉ [:continuous_events, :discrete_events]
         error("Trying to read an unsupported event type.")
+    end
     events_input = haskey(options, event_type) ? options[event_type].args[3] :
                    MacroTools.striplines(:(begin end))
     events_input = option_block_form(events_input)
@@ -642,11 +640,11 @@ function read_events_option(options, event_type::Symbol)
         # Formatting error checks.
         # NOTE: Maybe we should move these deeper into the system (rather than the DSL), throwing errors more generally?
         if (arg isa Expr) && (arg.head != :call) || (arg.args[1] != :(=>)) ||
-           length(arg.args) != 3
+                (length(arg.args) != 3)
             error("Events should be on form `condition => affect`, separated by a `=>`. This appears not to be the case for: $(arg).")
         end
         if (arg isa Expr) && (arg.args[2] isa Expr) && (arg.args[2].head != :vect) &&
-           (event_type == :continuous_events)
+                (event_type == :continuous_events)
             error("The condition part of continious events (the left-hand side) must be a vector. This is not the case for: $(arg).")
         end
         if (arg isa Expr) && (arg.args[3] isa Expr) && (arg.args[3].head != :vect)
@@ -670,8 +668,8 @@ function read_equations_options(options, variables_declared)
     eqs_input = haskey(options, :equations) ? options[:equations].args[3] : :(begin end)
     eqs_input = option_block_form(eqs_input)
     equations = Expr[]
-    ModelingToolkit.parse_equations!(
-        Expr(:block), equations, Dict{Symbol, Any}(), eqs_input)
+    ModelingToolkit.parse_equations!(Expr(:block), equations, 
+        Dict{Symbol, Any}(), eqs_input)
 
     # Loops through all equations, checks for lhs of the form `D(X) ~ ...`.
     # When this is the case, the variable X and differential D are extracted (for automatic declaration).
@@ -689,7 +687,7 @@ function read_equations_options(options, variables_declared)
         lhs = eq.args[2]
         # if lhs: is an expression. Is a function call. The function's name is D. Calls a single symbol.
         if (lhs isa Expr) && (lhs.head == :call) && (lhs.args[1] == :D) &&
-           (lhs.args[2] isa Symbol)
+                (lhs.args[2] isa Symbol)
             diff_var = lhs.args[2]
             if in(diff_var, forbidden_symbols_error)
                 error("A forbidden symbol ($(diff_var)) was used as an variable in this differential equation: $eq")
@@ -749,15 +747,15 @@ function read_observed_options(options, species_n_vars_declared, ivs_sorted)
                 error("An observable ($obs_name) was given independent variable(s). These should not be given, as they are inferred automatically.")
             isnothing(defaults) ||
                 error("An observable ($obs_name) was given a default value. This is forbidden.")
-            in(obs_name, forbidden_symbols_error) &&
+            (obs_name in forbidden_symbols_error) &&
                 error("A forbidden symbol ($(obs_eq.args[2])) was used as an observable name.")
 
             # Error checks.
             if (obs_name in species_n_vars_declared) && is_escaped_expr(obs_eq.args[2])
                 error("An interpoalted observable have been used, which has also been explicitly delcared within the system using eitehr @species or @variables. This is not permited.")
             end
             if ((obs_name in species_n_vars_declared) || is_escaped_expr(obs_eq.args[2])) &&
-               !isnothing(metadata)
+                    !isnothing(metadata)
                 error("Metadata was provided to observable $obs_name in the `@observables` macro. However, the obervable was also declared separately (using either @species or @variables). When this is done, metadata should instead be provided within the original @species or @variable declaration.")
             end
 
@@ -773,10 +771,10 @@ function read_observed_options(options, species_n_vars_declared, ivs_sorted)
                 # Adds a line to the `observed_vars` expression, setting the ivs for this observable.
                 # Cannot extract directly using e.g. "getfield.(dependants_structs, :reactant)" because
                 # then we get something like :([:X1, :X2]), rather than :([X1, X2]).
-                dep_var_expr = :(filter(
-                    !MT.isparameter, Symbolics.get_variables($(obs_eq.args[3]))))
-                ivs_get_expr = :(unique(reduce(
-                    vcat, [arguments(MT.unwrap(dep)) for dep in $dep_var_expr])))
+                dep_var_expr = :(filter(!MT.isparameter, 
+                    Symbolics.get_variables($(obs_eq.args[3]))))
+                ivs_get_expr = :(unique(reduce(vcat, [arguments(MT.unwrap(dep))
+                    for dep in $dep_var_expr])))
                 ivs_get_expr_sorted = :(sort($(ivs_get_expr);
                     by = iv -> findfirst(MT.getname(iv) == ivs for ivs in $ivs_sorted)))
                 push!(observed_vars.args,

src/expression_utils.jl

@@ -82,15 +82,15 @@ function find_varinfo_in_declaration(expr)
         # 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)
+                nothing)
     end
     if expr.head == :tuple
         # Case: X, [metadata=true]
         (expr.args[1] isa Symbol) && (return expr.args[1], [], nothing, expr.args[2])
         # Case: X(t), [metadata=true]
         (expr.args[1].head == :call) &&
             (return expr.args[1].args[1], expr.args[1].args[2:end], nothing, expr.args[2])
-        if (expr.args[1].head == :(=))
+        if expr.args[1].head == :(=)
             # Case: X = 1.0, [metadata=true]
             (expr.args[1].args[1] isa Symbol) &&
                 (return expr.args[1].args[1], [], expr.args[1].args[2], expr.args[2])

src/reaction.jl

@@ -367,9 +367,6 @@ encountered in:
     - Among potential noise scaling metadata.
 """
 function ModelingToolkit.get_variables!(set, rx::Reaction)
-    if isdefined(Main, :Infiltrator)
-        Main.infiltrate(@__MODULE__, Base.@locals, @__FILE__, @__LINE__)
-    end
     get_variables!(set, rx.rate)
     foreach(sub -> push!(set, sub), rx.substrates)
     foreach(prod -> push!(set, prod), rx.products)