use Vector{Pair{Symbol,R}} as metadata in Reactions

Author: TorkelE

docs/src/api/catalyst_api.md

@@ -178,7 +178,7 @@ substoichmat
 prodstoichmat
 netstoichmat
 reactionrates
-get_metadata_dict
+get_metadata_vec
 has_metadata
 get_metadata
 ```

src/Catalyst.jl

@@ -80,7 +80,7 @@ export mm, mmr, hill, hillr, hillar
 include("networkapi.jl")
 export species, nonspecies, reactionparams, reactions, speciesmap, paramsmap
 export numspecies, numreactions, numreactionparams, setdefaults!, symmap_to_varmap
-export get_metadata_dict, has_metadata, get_metadata
+export get_metadata_vec, has_metadata, get_metadata
 export make_empty_network, addspecies!, addparam!, addreaction!, reactionparamsmap
 export dependants, dependents, substoichmat, prodstoichmat, netstoichmat
 export conservationlaws, conservedquantities, conservedequations, conservationlaw_constants

src/reaction_network.jl

@@ -567,7 +567,7 @@ function get_rxexprs(rxstruct)
     prod_stoich_init = deepcopy(prod_init)
     reaction_func = :(Reaction($(recursive_expand_functions!(rxstruct.rate)), $subs_init,
                                $prod_init, $subs_stoich_init, $prod_stoich_init, 
-                               metadata = Dict($(rxstruct.metadata)),))
+                               metadata = $(rxstruct.metadata),))
     for sub in rxstruct.substrates
         push!(reaction_func.args[3].args, sub.reactant)
         push!(reaction_func.args[5].args, sub.stoichiometry)

src/reactionsystem.jl

@@ -120,7 +120,7 @@ struct Reaction{R, S, T}
     Contain additional data, such whenever the reaction have a specific noise-scaling expression for
     the chemical Langevin equation.
     """
-    metadata::Dict{Symbol, R}
+    metadata::Vector{Pair{Symbol, R}}
 end
 
 """
@@ -131,9 +131,8 @@ 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))
 
 function Reaction(rate, subs, prods, substoich, prodstoich;
-                  netstoich = nothing, metadata = Dict{Symbol,Any}(), 
-                  only_use_rate = (haskey(metadata, :only_use_rate) && Bool(metadata[:only_use_rate])),
-                  kwargs...)
+                  netstoich = nothing, metadata = Pair{Symbol, Any}[], 
+                  only_use_rate = metadata_only_use_rate_check(metadata), kwargs...)
     (isnothing(prods) && isnothing(subs)) &&
         throw(ArgumentError("A reaction requires a non-nothing substrate or product vector."))
     (isnothing(prodstoich) && isnothing(substoich)) &&
@@ -187,11 +186,25 @@ function Reaction(rate, subs, prods, substoich, prodstoich;
         convert.(stoich_type, netstoich) : netstoich
     end
 
-    haskey(metadata, :only_use_rate) && delete!(metadata, :only_use_rate)
+    # Check that all metadata entries are unique.
+    if length(unique(entry[1] for entry in metadata)) < length(metadata)
+        error("Repeated entries for the same metadata encountered in the following metadata set: $([entry[1] for entry in metadata]).")
+    end
+
+    # Deletes potential `:only_use_rate => ` entries from the metadata.
+    if any(:only_use_rate == entry[1] for entry in metadata) 
+        findfirst(:only_use_rate == entry[1] for entry in metadata)
+    end
 
     Reaction(value(rate), subs, prods, substoich′, prodstoich′, ns, only_use_rate, metadata)
 end
 
+# Checks if a metadata input has an entry :only_use_rate => true
+function metadata_only_use_rate_check(metadata)
+    any(:only_use_rate == entry[1] for entry in metadata) || (return false)
+    return metadata[findfirst(:only_use_rate == entry[1] for entry in metadata)] 
+end
+
 # three argument constructor assumes stoichiometric coefs are one and integers
 function Reaction(rate, subs, prods; kwargs...)
     sstoich = isnothing(subs) ? nothing : ones(Int, length(subs))
@@ -841,7 +854,7 @@ end
 ######################## Other accessors ##############################
 
 """
-    get_metadata_dict(reaction::Reaction)
+    get_metadata_vec(reaction::Reaction)
 
 Retrives the `ImmutableDict` containing all of the metadata associated with a specific reaction.
 
@@ -851,10 +864,10 @@ Arguments:
 Example:
 ```julia
 reaction = @reaction k, 0 --> X, [noise_scaling=0.0]
-get_metadata_dict(reaction)
+get_metadata_vec(reaction)
 ```
 """
-function get_metadata_dict(reaction::Reaction)
+function get_metadata_vec(reaction::Reaction)
     return reaction.metadata
 end
 
@@ -874,7 +887,7 @@ has_metadata(reaction, :noise_scaling)
 ```
 """
 function has_metadata(reaction::Reaction, md_key::Symbol)
-    return haskey(get_metadata_dict(reaction), md_key)
+    return any(isequal(md_key, entry[1]) for entry in get_metadata_vec(reaction))
 end
 
 """
@@ -894,9 +907,9 @@ get_metadata(reaction, :noise_scaling)
 """
 function get_metadata(reaction::Reaction, md_key::Symbol)
     if !has_metadata(reaction, md_key) 
-        error("The reaction does not have a metadata field $md_key. It does have the following metadata fields: $(keys(get_metadata_dict(reaction))).")
+        error("The reaction does not have a metadata field $md_key. It does have the following metadata fields: $(keys(get_metadata_vec(reaction))).")
     end
-    return get_metadata_dict(reaction)[md_key]
+    return get_metadata_vec(reaction)[findfirst(isequal(md_key, entry[1]) for entry in get_metadata_vec(reaction))][2]
 end
 
 ######################## Conversion to ODEs/SDEs/jump, etc ##############################

test/dsl/dsl_basics.jl

@@ -143,14 +143,14 @@ let
     @parameters k η
     @species X(t) X2(t)
 
-    metadata1 = Dict(:noise_scaling => η)
+    metadata1 = [:noise_scaling => η]
     r1 = Reaction(k, [X], [X2], [2], [1]; metadata=metadata1)
 
-    metadata2 = Dict(:md_1 => 1.0, :md_2 => false, :md_3 => "Hello world", :md_4 => :sym, 
-                     :md_5 => X + X2^k -1, :md_6 => (0.1, 2.0))
+    metadata2 = [:md_1 => 1.0, :md_2 => false, :md_3 => "Hello world", :md_4 => :sym, 
+                     :md_5 => X + X2^k -1, :md_6 => (0.1, 2.0)]
     r2 = Reaction(k, [X], [X2], [2], [1]; metadata=metadata2)
 
-    metadata3 = Dict{Symbol,Any}()
+    metadata3 = Pair{Symbol,Any}[]
     r3 = Reaction(k, [X], [X2], [2], [1]; metadata=metadata3)
 
     # Creates reactions using DSL.
@@ -164,9 +164,9 @@ let
     # Checks DSL reactions are correct.
     rxs = reactions(rs)
     @test isequal([r1, r2, r3], rxs)
-    @test isequal(get_metadata_dict(r1), get_metadata_dict(rxs[1]))
-    @test isequal(get_metadata_dict(r2), get_metadata_dict(rxs[2]))
-    @test isequal(get_metadata_dict(r3), get_metadata_dict(rxs[3]))
+    @test isequal(get_metadata_vec(r1), get_metadata_vec(rxs[1]))
+    @test isequal(get_metadata_vec(r2), get_metadata_vec(rxs[2]))
+    @test isequal(get_metadata_vec(r3), get_metadata_vec(rxs[3]))
 
     # Checks that accessor functions works on the DSL.
     @test has_metadata(rxs[1], :noise_scaling)
@@ -185,9 +185,9 @@ let
     rx3 = @reaction k, 2X --> X2
 
     @test isequal([rx1, rx2, rx3], rxs)
-    @test isequal(get_metadata_dict(rx1), get_metadata_dict(rxs[1]))
-    @test isequal(get_metadata_dict(rx2), get_metadata_dict(rxs[2]))
-    @test isequal(get_metadata_dict(rx3), get_metadata_dict(rxs[3]))
+    @test isequal(get_metadata_vec(rx1), get_metadata_vec(rxs[1]))
+    @test isequal(get_metadata_vec(rx2), get_metadata_vec(rxs[2]))
+    @test isequal(get_metadata_vec(rx3), get_metadata_vec(rxs[3]))
 end
 
 # Checks that repeated metadata throws errors.

test/reactionsystem_structure/reactions.jl

@@ -7,18 +7,22 @@ using Catalyst, Test
 
 # Tests creation.
 # Tests basic accessor functions.
+# Tests that repeated metadata entries are not permitted.
 let
     @variables t
     @parameters k
     @species X(t) X2(t)
 
-    metadata = Dict(:noise_scaling => 0.0)
+    metadata = [:noise_scaling => 0.0]
     r = Reaction(k, [X], [X2], [2], [1]; metadata=metadata)
 
-    @test get_metadata_dict(r) == Dict(:noise_scaling => 0.0)
+    @test get_metadata_vec(r) == [:noise_scaling => 0.0]
     @test has_metadata(r, :noise_scaling)
     @test !has_metadata(r, :nonexisting_metadata)
     @test get_metadata(r, :noise_scaling) == 0.0
+
+    metadata_repeated = [:noise_scaling => 0.0, :noise_scaling => 1.0, :metadata_entry => "unused"]
+    @test_throws Exception Reaction(k, [X], [X2], [2], [1]; metadata=metadata_repeated)
 end
 
 # Tests accessors for system without metadata.
@@ -27,12 +31,12 @@ let
     @parameters k
     @species X(t) X2(t)
 
-    metadata = Dict{Symbol,Any}()
+    metadata = Pair{Symbol,Any}[]
     r1 = Reaction(k, [X], [X2], [2], [1])
     r2 = Reaction(k, [X], [X2], [2], [1]; metadata=metadata)
 
     @test isequal(r1, r2)
-    @test get_metadata_dict(r1) == Dict()
+    @test get_metadata_vec(r1) == Pair{Symbol,Any}[]
     @test !has_metadata(r1, :md)
 end
 
@@ -44,12 +48,12 @@ let
     @parameters k
     @species X(t) X2(t)
 
-    metadata = Dict(:md_1 => 1.0, :md_2 => false, :md_3 => "Hello world", :md_4 => :sym, 
-                                  :md_5 => X + X2^k -1, :md_6 => (0.1, 2.0))
+    metadata = [:md_1 => 1.0, :md_2 => false, :md_3 => "Hello world", :md_4 => :sym, 
+                                  :md_5 => X + X2^k -1, :md_6 => (0.1, 2.0)]
     r = Reaction(k, [X], [X2], [2], [1]; metadata=metadata)
 
-    @test isequal(get_metadata_dict(r), Dict(:md_1 => 1.0, :md_2 => false, :md_3 => "Hello world", 
-                                                     :md_4 => :sym, :md_5 => X + X2^k -1, :md_6 => (0.1, 2.0)))
+    @test isequal(get_metadata_vec(r), [:md_1 => 1.0, :md_2 => false, :md_3 => "Hello world", 
+                                        :md_4 => :sym, :md_5 => X + X2^k -1, :md_6 => (0.1, 2.0)])
     @test has_metadata(r, :md_1)
     @test has_metadata(r, :md_2)
     @test has_metadata(r, :md_3)