move functions back

Author: TorkelE

src/reaction_structure.jl

@@ -63,6 +63,31 @@ Test if a species is valid as a reactant (i.e. a species variable or a constant
 isvalidreactant(s) = MT.isparameter(s) ? isconstant(s) : (isspecies(s) && !isconstant(s))
 
 
+### Reaction Constructor Functions ###
+
+# Checks if a metadata input has an entry :only_use_rate => true
+function metadata_only_use_rate_check(metadata)
+    only_use_rate_idx = findfirst(:only_use_rate == entry[1] for entry in metadata)
+    isnothing(only_use_rate_idx) && return false
+    return Bool(metadata[only_use_rate_idx][2])
+end
+
+# calculates the net stoichiometry of a reaction as a vector of pairs (sub,substoich)
+function get_netstoich(subs, prods, sstoich, pstoich)
+    # stoichiometry as a Dictionary
+    nsdict = Dict{Any, eltype(sstoich)}(sub => -sstoich[i] for (i, sub) in enumerate(subs))
+    for (i, p) in enumerate(prods)
+        coef = pstoich[i]
+        @inbounds nsdict[p] = haskey(nsdict, p) ? nsdict[p] + coef : coef
+    end
+
+    # stoichiometry as a vector
+    [el for el in nsdict if !_iszero(el[2])]
+end
+
+# Get the net stoichiometries' type.
+netstoich_stoichtype(::Vector{Pair{S, T}}) where {S, T} = T
+
 ### Reaction Structure ###
 
 """
@@ -214,29 +239,6 @@ function Reaction(rate, subs, prods; kwargs...)
     Reaction(rate, subs, prods, sstoich, pstoich; kwargs...)
 end
 
-# Checks if a metadata input has an entry :only_use_rate => true
-function metadata_only_use_rate_check(metadata)
-    only_use_rate_idx = findfirst(:only_use_rate == entry[1] for entry in metadata)
-    isnothing(only_use_rate_idx) && return false
-    return Bool(metadata[only_use_rate_idx][2])
-end
-
-# calculates the net stoichiometry of a reaction as a vector of pairs (sub,substoich)
-function get_netstoich(subs, prods, sstoich, pstoich)
-    # stoichiometry as a Dictionary
-    nsdict = Dict{Any, eltype(sstoich)}(sub => -sstoich[i] for (i, sub) in enumerate(subs))
-    for (i, p) in enumerate(prods)
-        coef = pstoich[i]
-        @inbounds nsdict[p] = haskey(nsdict, p) ? nsdict[p] + coef : coef
-    end
-
-    # stoichiometry as a vector
-    [el for el in nsdict if !_iszero(el[2])]
-end
-
-# Get the net stoichiometries' type.
-netstoich_stoichtype(::Vector{Pair{S, T}}) where {S, T} = T
-
 # Union type for `Reaction`s and `Equation`s.
 const CatalystEqType = Union{Reaction, Equation}
 

src/reactionsystem_conversions.jl

@@ -441,6 +441,16 @@ function spatial_convert_err(rs::ReactionSystem, systype)
     isspatial(rs) && error("Conversion to $systype is not supported for spatial networks.")
 end
 
+# Finds and differentials in an expression, and sets these to 0.
+function remove_diffs(expr)
+    if Symbolics._occursin(Symbolics.is_derivative, expr)
+        return Symbolics.replace(expr, diff_2_zero)
+    else
+        return expr
+    end
+end
+diff_2_zero(expr) = (Symbolics.is_derivative(expr) ? 0.0 : expr)
+
 COMPLETENESS_ERROR = "A ReactionSystem must be complete before it can be converted to other system types. A ReactionSystem can be marked as complete using the `complete` function."
 
 
@@ -531,16 +541,6 @@ function Base.convert(::Type{<:NonlinearSystem}, rs::ReactionSystem; name = name
                     kwargs...)
 end
 
-# Finds and differentials in an expression, and sets these to 0.
-function remove_diffs(expr)
-    if Symbolics._occursin(Symbolics.is_derivative, expr)
-        return Symbolics.replace(expr, diff_2_zero)
-    else
-        return expr
-    end
-end
-diff_2_zero(expr) = (Symbolics.is_derivative(expr) ? 0.0 : expr)
-
 # Ideally, when `ReactionSystem`s are converted to `NonlinearSystem`s, any coupled ODEs should be 
 # on the form D(X) ~ ..., where lhs is the time derivative w.r.t. a single variable, and the rhs
 # does not contain any differentials. If this is not teh case, we throw a warning to let the user

src/reactionsystem_structure.jl

@@ -141,6 +141,70 @@ function reset!(nps::NetworkProperties{I, V}) where {I, V}
 end
 
 
+### ReactionSystem Constructor Functions ###
+
+# Used to sort the reaction/equation vector as reactions first, equations second.
+eqsortby(eq::CatalystEqType) = eq isa Reaction ? 1 : 2
+
+# Figures out a type.
+function get_speciestype(iv, unknowns, systems)
+    T = Nothing
+    !isempty(unknowns) && (T = typeof(first(unknowns)))
+
+    if !isempty(systems)
+        for sys in Iterators.filter(s -> s isa ReactionSystem, systems)
+            sts = MT.unknowns(sys)
+            if !isempty(sts)
+                T = typeof(first(sts))
+                break
+            end
+        end
+    end
+
+    if T <: Nothing
+        @variables A($iv)
+        T = typeof(MT.unwrap(A))
+    end
+
+    T
+end
+
+# search the symbolic expression for parameters or unknowns
+# and save in ps and us respectively. vars is used to cache results
+function findvars!(ps, us, exprtosearch, ivs, vars)
+    MT.get_variables!(vars, exprtosearch)
+    for var in vars
+        (var ∈ ivs) && continue
+        if MT.isparameter(var)
+            push!(ps, var)
+        else
+            push!(us, var)
+        end
+    end
+    empty!(vars)
+end
+# Special dispatch for equations, applied `findvars!` to left-hand and right-hand sides.
+function findvars!(ps, us, eq_to_search::Equation, ivs, vars)
+    findvars!(ps, us, eq_to_search.lhs, ivs, vars)
+    findvars!(ps, us, eq_to_search.rhs, ivs, vars)
+end
+# Special dispatch for Vectors (applies it to each vector element).
+function findvars!(ps, us, exprs_to_search::Vector, ivs, vars)
+    foreach(exprtosearch -> findvars!(ps, us, exprtosearch, ivs, vars), exprs_to_search)
+end
+
+# Loops through all events in an supplied event vector, adding all unknowns and parameters found in
+# its condition and affect functions to their respective vectors (`ps` and `us`).
+function find_event_vars!(ps, us, events::Vector, ivs, vars)
+    foreach(event -> find_event_vars!(ps, us, event, ivs, vars), events)
+end
+# For a single event, adds quantitites from its condition and affect expression(s) to `ps` and `us`.
+# Applies `findvars!` to the event's condition (`event[1])` and affec (`event[2]`).
+function find_event_vars!(ps, us, event, ivs, vars)
+    findvars!(ps, us, event[1], ivs, vars)
+    findvars!(ps, us, event[2], ivs, vars)
+end
+
 ### ReactionSystem Structure ###
 
 """
@@ -370,32 +434,6 @@ function ReactionSystem(eqs, iv, unknowns, ps;
                    ccallbacks, dcallbacks, metadata; checks = checks)
 end
 
-# Used to sort the reaction/equation vector as reactions first, equations second.
-eqsortby(eq::CatalystEqType) = eq isa Reaction ? 1 : 2
-
-# Figures out a type.
-function get_speciestype(iv, unknowns, systems)
-    T = Nothing
-    !isempty(unknowns) && (T = typeof(first(unknowns)))
-
-    if !isempty(systems)
-        for sys in Iterators.filter(s -> s isa ReactionSystem, systems)
-            sts = MT.unknowns(sys)
-            if !isempty(sts)
-                T = typeof(first(sts))
-                break
-            end
-        end
-    end
-
-    if T <: Nothing
-        @variables A($iv)
-        T = typeof(MT.unwrap(A))
-    end
-
-    T
-end
-
 # Two-argument constructor (reactions/equations and time variable).
 # Calls the `make_ReactionSystem_internal`, which in turn calls the four-argument constructor.
 function ReactionSystem(rxs::Vector, iv = Catalyst.DEFAULT_IV; kwargs...)
@@ -484,42 +522,6 @@ function make_ReactionSystem_internal(rxs_and_eqs::Vector, iv, us_in, ps_in; spa
     ReactionSystem(fulleqs, t, usv, psv; spatial_ivs, continuous_events, discrete_events, observed, kwargs...)
 end
 
-# search the symbolic expression for parameters or unknowns
-# and save in ps and us respectively. vars is used to cache results
-function findvars!(ps, us, exprtosearch, ivs, vars)
-    MT.get_variables!(vars, exprtosearch)
-    for var in vars
-        (var ∈ ivs) && continue
-        if MT.isparameter(var)
-            push!(ps, var)
-        else
-            push!(us, var)
-        end
-    end
-    empty!(vars)
-end
-# Special dispatch for equations, applied `findvars!` to left-hand and right-hand sides.
-function findvars!(ps, us, eq_to_search::Equation, ivs, vars)
-    findvars!(ps, us, eq_to_search.lhs, ivs, vars)
-    findvars!(ps, us, eq_to_search.rhs, ivs, vars)
-end
-# Special dispatch for Vectors (applies it to each vector element).
-function findvars!(ps, us, exprs_to_search::Vector, ivs, vars)
-    foreach(exprtosearch -> findvars!(ps, us, exprtosearch, ivs, vars), exprs_to_search)
-end
-
-# Loops through all events in an supplied event vector, adding all unknowns and parameters found in
-# its condition and affect functions to their respective vectors (`ps` and `us`).
-function find_event_vars!(ps, us, events::Vector, ivs, vars)
-    foreach(event -> find_event_vars!(ps, us, event, ivs, vars), events)
-end
-# For a single event, adds quantitites from its condition and affect expression(s) to `ps` and `us`.
-# Applies `findvars!` to the event's condition (`event[1])` and affec (`event[2]`).
-function find_event_vars!(ps, us, event, ivs, vars)
-    findvars!(ps, us, event[1], ivs, vars)
-    findvars!(ps, us, event[2], ivs, vars)
-end
-
 
 ### Base Functions ###
 
@@ -974,6 +976,9 @@ function prodstoichmat(rn::ReactionSystem; sparse = false)
     sparse ? prodstoichmat(SparseMatrixCSC{T, Int}, rn) : prodstoichmat(Matrix{T}, rn)
 end
 
+# Used in `netstoichmat` function.
+netstoichtype(::Vector{Pair{S, T}}) where {S, T} = T
+
 """
     netstoichmat(rn, sparse=false)
 
@@ -1044,11 +1049,18 @@ function netstoichmat(rn::ReactionSystem; sparse = false)
     nsmat
 end
 
-netstoichtype(::Vector{Pair{S, T}}) where {S, T} = T
-
-
 ### General `ReactionSystem`-specific Functions ###
 
+# used in the `__unpacksys` function.
+function __unpacksys(rn)
+    ex = :(begin end)
+    for key in keys(get_var_to_name(rn))
+        var = MT.getproperty(rn, key, namespace = false)
+        push!(ex.args, :($key = $var))
+    end
+    ex
+end
+
 """
     @unpacksys sys::ModelingToolkit.AbstractSystem
 
@@ -1080,15 +1092,6 @@ macro unpacksys(rn)
     end
 end
 
-function __unpacksys(rn)
-    ex = :(begin end)
-    for key in keys(get_var_to_name(rn))
-        var = MT.getproperty(rn, key, namespace = false)
-        push!(ex.args, :($key = $var))
-    end
-    ex
-end
-
 """
     setdefaults!(rn, newdefs)
 
@@ -1263,6 +1266,21 @@ function make_empty_network(; iv = DEFAULT_IV, name = gensym(:ReactionSystem))
     ReactionSystem(Reaction[], iv, [], []; name = name)
 end
 
+# A helper function used in `flatten`.
+function getsubsystypes(sys)
+    typeset = Set{Type}()
+    getsubsystypes!(typeset, sys)
+    typeset
+end
+
+function getsubsystypes!(typeset::Set{Type}, sys::T) where {T <: MT.AbstractSystem}
+    push!(typeset, T)
+    for subsys in get_systems(sys)
+        getsubsystypes!(typeset, subsys)
+    end
+    typeset
+end
+
 """
     Catalyst.flatten(rs::ReactionSystem)
 
@@ -1357,22 +1375,6 @@ function ModelingToolkit.extend(sys::MT.AbstractSystem, rs::ReactionSystem;
                    discrete_events)
 end
 
-# A helper function.
-function getsubsystypes(sys)
-    typeset = Set{Type}()
-    getsubsystypes!(typeset, sys)
-    typeset
-end
-
-function getsubsystypes!(typeset::Set{Type}, sys::T) where {T <: MT.AbstractSystem}
-    push!(typeset, T)
-    for subsys in get_systems(sys)
-        getsubsystypes!(typeset, subsys)
-    end
-    typeset
-end
-
-
 ### Units Handling ###
 
 """