fix subparts access

Author: thevolatilebit

Project.toml

@@ -1,6 +1,6 @@
 name = "ReactiveDynamics"
 uuid = "c7456e7d-545a-4b79-91ea-6e93d96dd4d4"
-version = "0.2.1"
+version = "0.2.2"
 
 [deps]
 CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b"

readme.md

@@ -67,8 +67,8 @@ using ReactiveDynamics
 
 # model dynamics
 sir_acs = @ReactionNetwork begin
-        α*S*I, S+I --> 2I, cycle_time=>0, name=>I2R
-        β*I, I --> R, cycle_time=>0, name=>R2S 
+        α*S*I, S+I --> 2I, name=>I2R
+        β*I, I --> R, name=>R2S 
 end
 
 # simulation parameters

src/ReactiveDynamics.jl

@@ -83,7 +83,7 @@ prettynames = Dict(
 )
 
 defargs = Dict(
-    :T => Dict{Symbol, Any}(:transPriority => 1, :transProbOfSuccess => 1, :transCapacity => Inf, :transCycleTime => 1,
+    :T => Dict{Symbol, Any}(:transPriority => 1, :transProbOfSuccess => 1, :transCapacity => Inf, :transCycleTime => 0.,
         :transMaxLifeTime => Inf, :transMultiplier=>1, :transPostAction => :(), :transName => missing),
     :S => Dict{Symbol, Any}(:specInitUncertainty => .0, :specInitVal => .0, :specCost => .0, :specReward => .0, :specValuation => .0),
     :P => Dict{Symbol, Any}(:prmVal => missing),
@@ -96,14 +96,14 @@ species_modalities = [:nonblock, :conserved, :rate]
 
 function assign_defaults!(acs::ReactionNetwork)
     for (_, v_) in defargs, (k, v) in v_
-        for i in eachindex(acs.subparts[k])
-            !isassigned(acs.subparts[k], i) && (acs.subparts[k][i] = v)
+        for i in 1:length(subpart(acs, k))
+            !isassigned(subpart(acs, k), i) && (subpart(acs, k)[i] = v)
         end
     end
-    
-    foreach(i -> isassigned(acs.subparts.specModality, i) || (acs.subparts.specModality[i] = Set{Symbol}()), 1:nparts(acs, :S))
+
+    foreach(i -> isassigned(subpart(acs, :specModality), i) || (subpart(acs, :specModality)[i] = Set{Symbol}()), 1:nparts(acs, :S))
     k = [:specCost, :specReward, :specValuation]
-    foreach(k -> foreach(i -> isassigned(getproperty(acs.subparts, k), i) || (getproperty(acs.subparts, k)[i] = .0), 1:nparts(acs, :S)), k)
+    foreach(k -> foreach(i -> isassigned(subpart(acs, k), i) || (subpart(acs, k)[i] = .0), 1:nparts(acs, :S)), k)
 
     acs
 end
@@ -144,4 +144,9 @@ include.(readdir(joinpath(@__DIR__, "operators"), join=true))
 include("solvers.jl"); include("optim.jl")
 include("loadsave.jl")
 
+# Catlab.jl hack: bypass @isdefined check
+function Base.getindex(m::Catlab.ColumnImplementations.PartialVecMap, x::Int)
+    m.v[x]
+end
+
 end

src/compilers.jl

@@ -89,7 +89,7 @@ function compile_attrs(acs::ReactionNetwork)
     wrap_fun = ex -> wrap_expr(ex, species_names, prm_names, varmap)
     attrs = Dict{Symbol, Vector}(); transitions = Dict{Symbol, Vector}()
     for attr in propertynames(acs.subparts)
-        attrs_ = getproperty(acs.subparts, attr)
+        attrs_ = subpart(acs, attr)
         !contains(string(attr), "trans") ?
             (attrs[attr] = map(i -> skip_compile(attr) ? attrs_[i] : wrap_fun(attrs_[i]), 1:length(attrs_))) :
             (transitions[attr] = map(i -> skip_compile(attr) ? attrs_[i] : wrap_fun(attrs_[i]), 1:length(attrs_)))
@@ -104,7 +104,7 @@ end
 function remove_choose(acs::ReactionNetwork)
     acs = deepcopy(acs); pcs = []
     for attr in propertynames(acs.subparts)
-        attrs_ = getproperty(acs.subparts, attr)
+        attrs_ = subpart(acs, attr)
         foreach(i -> isassigned(attrs_, i) && attrs_[i] isa Expr && (attrs_[i] = normalize_pcs!(pcs, attrs_[i])), 1:length(attrs_))
     end
 

src/interface/update.jl

@@ -81,11 +81,11 @@ end
 function mode!(acs, dict)
     for (spex, mods) in dict
         i = if spex isa Regex
-            incident_pattern(spex, getproperty(acs.subparts, :specName))
+            incident_pattern(spex, acs[:, :specName])
         else incident(acs, Symbol(spex), :specName) end
 
         for ix in i
-            !isassigned(acs.subparts.specModality, ix) && (acs.subparts.specModality[ix] = Set{Symbol}())
+            !isassigned(subpart(acs, specModality), ix) && (acs[ix, specModality] = Set{Symbol}())
             union!(acs[ix, :specModality], mods)
         end
     end
@@ -124,7 +124,7 @@ end
 function set_valuation!(acs, dict, valuation_type)
     for (spex, val) in dict
         i = if spex isa Regex
-            incident_pattern(spex, getproperty(acs.subparts, :specName))
+            incident_pattern(spex, subpart(acs, :specName))
         else incident(acs, Symbol(spex), :specName) end
 
         foreach(ix -> acs[ix, Symbol(:spec, Symbol(uppercasefirst(string(valuation_type))))] = eval(val), i)
@@ -207,10 +207,10 @@ end
 macro prob_init_from_vec(acsex, vecex) :(init!($(esc(acsex)), $(esc(vecex)))) end
 
 function init!(acs, inits)
-    inits isa AbstractVector && length(inits) == nparts(acs, :S) && (acs.subparts.specInitVal .= inits; return)
+    inits isa AbstractVector && length(inits) == nparts(acs, :S) && (subpart(acs, :specInitVal) .= inits; return)
     inits isa AbstractDict && for (k, init_val) in inits
         k isa Number ? acs[k, :specInitVal] = init_val : begin
-                i = k isa Regex ? incident_pattern(k, getproperty(acs.subparts, :specName)) :
+                i = k isa Regex ? incident_pattern(k, subpart(acs, :specName)) :
                     incident(acs, k, :specName)
                 foreach(ix -> (acs[ix, :specInitVal] = init_val), i)
         end
@@ -246,10 +246,10 @@ macro prob_uncertainty(acsex, exs...)
 end
 
 function uncinit!(acs, inits)
-    inits isa AbstractVector && length(inits) == nparts(acs, :S) && (acs.subparts.specInitUncertainty .= inits; return)
+    inits isa AbstractVector && length(inits) == nparts(acs, :S) && (subpart(acs, :specInitUncertainty) .= inits; return)
     inits isa AbstractDict && for (k, init_val) in inits
         k isa Number ? acs[k, :specInitUncertainty] = init_val : begin
-                i = k isa Regex ? incident_pattern(k, getproperty(acs.subparts, :specName)) :
+                i = k isa Regex ? incident_pattern(k, subpart(acs, :specName)) :
                     incident(acs, k, :specName)
                 foreach(ix -> (acs[ix, :specInitUncertainty] = init_val), i)
         end
@@ -262,7 +262,7 @@ function set_params!(acs, params)
     params isa AbstractDict && for (k, init_val) in params
         k = get_pattern(k)
         if k isa Regex 
-            i = incident_pattern(k, getproperty(acs.subparts, :prmName))
+            i = incident_pattern(k, subpart(acs, :prmName))
         else
             i = incident(acs, k, :prmName)
             isempty(i) && (i = add_part!(acs, :P, prmName=k))

src/operators/equalize.jl

@@ -33,7 +33,7 @@ function equalize!(acs::ReactionNetwork,  eqs=[])
 
     for attr in propertynames(acs.subparts)
         attr == :specName && continue
-        attr_ = getproperty(acs.subparts, attr)
+        attr_ = acs[:, attr]
         for i in 1:length(attr_)
             attr_[i] = escape_ref(attr_[i], collect(keys(specmap)))
             attr_[i] = recursively_substitute_vars!(specmap, attr_[i])

src/operators/joins.jl

@@ -10,6 +10,8 @@ function union_acs!(acs1, acs2, name=gensym("acs_"), eqs=[])
     for i in 1:nparts(acs2, :S)
         inc = incident(acs1, acs2[i, :specName], :specName)
         isempty(inc) && (inc = add_part!(acs1, :S; specName=acs2[i, :specName]); assign_defaults!(acs1))
+        return (acs1, acs2)
+        println(first(inc)); println(acs1[first(inc), :specModality]); println(); println(acs2[:, :specModality]);
         union!(acs1[first(inc), :specModality], acs2[i, :specModality])
 
         for attr in propertynames(acs1.subparts)
@@ -51,7 +53,7 @@ function prepend!(acs::ReactionNetwork, name=gensym("acs"), eqs=[])
 
     for attr in propertynames(acs.subparts)
         attr == :specName && continue
-        attr_ = getproperty(acs.subparts, attr)
+        attr_ = acs[:, attr]
         for i in 1:length(attr_)
             attr_[i] = escape_ref(attr_[i], collect(keys(specmap)))
             attr_[i] = recursively_substitute_vars!(specmap, attr_[i])

src/optim.jl

@@ -140,7 +140,7 @@ function get_free_vars(acs, args)
     u0_ = []; for (k, v) in u0;
         if k isa Number push!(u0_, Int(k) => v)
         else 
-            for i in 1:length(acs.subparts.specName)
+            for i in 1:length(subpart(acs, :specName))
                 (acs[i, :specName] == k) && (push!(u0_, i => v); break)
             end
         end
@@ -158,8 +158,8 @@ function get_vars(acs, args)
         arg = recursively_expand_dots(arg)
         if arg isa Number push!(args_, Int(arg))
         else 
-            for i in 1:length(acs.subparts.specName)
-                isassigned(acs.subparts.specName, i) && (acs[i, :specName] == arg) &&
+            for i in 1:length(subpart(acs, :specName))
+                isassigned(subpart(acs, :specName), i) && (acs[i, :specName] == arg) &&
                     (push!(args_, i); break)
             end
         end

src/solvers.jl

@@ -237,7 +237,11 @@ DiscreteProblem(acs, u0, p; tspan=(.0, 100.), schedule=schedule_weighted!)
 """
 function DiffEqBase.DiscreteProblem(acs::ReactionNetwork, u0=Dict(), p=DiffEqBase.NullParameters(); kwargs...)
     assign_defaults!(acs)
-    keywords = Dict{Symbol, Any}([acs[i, :metaKeyword] => acs[i, :metaVal] for i in 1:nparts(acs, :M) if isassigned(acs.subparts[:metaKeyword], i) && isassigned(acs.subparts[:metaVal], i)])
+    keywords = Dict{Symbol, Any}(
+        [
+            acs[i, :metaKeyword] => acs[i, :metaVal]  for i in 1:nparts(acs, :M) if isassigned(subpart(acs, :metaKeyword), i) && isassigned(subpart(acs, :metaVal), i)
+        ]
+    )
     merge!(keywords, Dict(collect(kwargs))); merge!(keywords,  Dict(:strategy => get(keywords, :alloc_strategy, :weighted)))       
     keywords[:tspan], keywords[:tstep] = get_tcontrol(keywords[:tspan], keywords)
 
@@ -247,7 +251,7 @@ function DiffEqBase.DiscreteProblem(acs::ReactionNetwork, u0=Dict(), p=DiffEqBas
     prob = transform(DiffEqBase.DiscreteProblem, state; kwargs...)
 
     u0 isa Dict &&
-        foreach(i -> prob.u0[i] = isassigned(acs.subparts[:specName], i) && haskey(u0, acs[i, :specName]) ? u0[acs[i, :specName]] : prob.u0[i], 1:nparts(state, :S))
+        foreach(i -> prob.u0[i] = isassigned(subpart(acs, :specName), i) && haskey(u0, acs[i, :specName]) ? u0[acs[i, :specName]] : prob.u0[i], 1:nparts(state, :S))
     p_ = p == DiffEqBase.NullParameters() ? Dict() : Dict(k => v for (k, v) in p)
     prob = remake(prob; u0=prob.u0, tspan=keywords[:tspan], dt=get(keywords, :tstep, 1),
         p=merge(prob.p, p_, Dict(:tstep => get(keywords, :tstep, 1), :strategy => get(keywords, :alloc_strategy, :weighted)))
@@ -256,7 +260,7 @@ function DiffEqBase.DiscreteProblem(acs::ReactionNetwork, u0=Dict(), p=DiffEqBas
     prob
 end
 
-fetch_params(acs::ReactionNetwork) = Dict{Symbol, Any}((acs[i, :prmName] => acs[i, :prmVal] for i in Iterators.filter(i -> isassigned(acs.subparts[:prmVal], i), 1:nparts(acs, :P))))
+fetch_params(acs::ReactionNetwork) = Dict{Symbol, Any}((acs[i, :prmName] => acs[i, :prmVal] for i in Iterators.filter(i -> isassigned(subpart(acs, :prmVal), i), 1:nparts(acs, :P))))
 
 # EnsembleProblem's prob_func: sample initial values
 function get_prob_func(prob)

src/state.jl

@@ -49,7 +49,7 @@ mutable struct ReactiveDynamicsState
         ongoing_transitions = Transition[]
         log = NamedTuple[]
         observables = compile_observables(acs)
-        transitions_attrs = setdiff(filter(a -> contains(string(a), "trans"), keys(acs.subparts)), (:trans,)) ∪ 
+        transitions_attrs = setdiff(filter(a -> contains(string(a), "trans"), propertynames(acs.subparts)), (:trans,)) ∪ 
             [:transLHS, :transRHS, :transToSpawn, :transHash]
         transitions = Dict{Symbol, Vector}(a => [] for a in transitions_attrs)