Generalized System struct

[shashi]

struct JumpSystem{U <: ArrayPartition} <: AbstractSystem
    eqs::U
    iv::Variable
    states::Vector{Variable}
    ps::Vector{Variable}
    pins::Vector{Variable}
    observed::Vector{Equation}
    name::Symbol
    systems::Vector{JumpSystem}
end
struct NonlinearSystem <: AbstractSystem
    eqs::Vector{Equation}
    states::Vector{Variable}
    ps::Vector{Variable}
    pins::Vector{Variable}
    observed::Vector{Equation}
    name::Symbol
    systems::Vector{NonlinearSystem}
end
struct OptimizationSystem <: AbstractSystem
    op::Operation
    states::Vector{Variable}
    ps::Vector{Variable}
    pins::Vector{Variable}
    observed::Vector{Equation}
    name::Symbol
    systems::Vector{OptimizationSystem}
end
struct ReactionSystem <: AbstractSystem
    eqs::Vector{Reaction}
    iv::Variable
    states::Vector{Variable}
    ps::Vector{Variable}
    pins::Vector{Variable}
    observed::Vector{Equation}
    name::Symbol
    systems::Vector{ReactionSystem}
end
struct ODESystem <: AbstractODESystem
    eqs::Vector{Equation}
    iv::Variable
    states::Vector{Variable}
    ps::Vector{Variable}
    pins::Vector{Variable}
    observed::Vector{Equation}
    tgrad::RefValue{Vector{Expression}}
    jac::RefValue{Any}
    Wfact::RefValue{Matrix{Expression}}
    Wfact_t::RefValue{Matrix{Expression}}
    name::Symbol
    systems::Vector{ODESystem}
end
struct SDESystem <: AbstractODESystem
    eqs::Vector{Equation}
    noiseeqs::AbstractArray{Operation}
    iv::Variable
    states::Vector{Variable}
    ps::Vector{Variable}
    pins::Vector{Variable}
    observed::Vector{Equation}
    tgrad::RefValue{Vector{Expression}}
    jac::RefValue{Matrix{Expression}}
    Wfact::RefValue{Matrix{Expression}}
    Wfact_t::RefValue{Matrix{Expression}}
    name::Symbol
    systems::Vector{SDESystem}
end

Should probably be combined to

struct System{T}
    systemparams::T
    eqs::Vector
    iv::Operation
    states::Vector
    ps::Vector
    pins::Vector
    observed::Vector
    cache::Dict
    name::Symbol
end
# interface, possibly memoized in `cache`
equations(s::System, states=states(s))
states(s::System) # should return OrderedSet.
parameters(s::System)
pins(s::System)
observed(s::System, states=states(s))

A big reason is right now it's so hard to generically build a system back. (e.g. you'd have to write flatten for every system type, even though it would have the exact same code.)

Any objections?

[YingboMa]

That structure looks good to me, since it's all non-isbit data, there's not much concern regarding memory layout overhead.

[shashi]

Also this is a handy macro to use to store stuff in the cache:

macro syscache(sys, name, expr)
    qname = QuoteNode(name)
    quote
        Base.get!(()->$expr, $sys.cache, $qname)
    end |> esc
end

Example:

function states(sys::System)
    @syscache sys states begin
        OrderedSet(isempty(sys.systems) ?
                   setdiff(sys.states, value.(sys.pins)) :
                   [sys.states; reduce(vcat,namespace_variables.(sys.systems))])

    end
end

[isaacsas]

For JumpSystems we don't use a vector to store the equations though, and I'm thinking we may want to rethink how it represents/stores MassActionJumps to cut down on allocations when doing conversions from ReactionSystems.

[isaacsas]

Although, perhaps we shouldn't think of the jumps as being the equations for a Jumpsystem. Equations could be for mathematical models with jumps (like Gillespie equations, or tau-leaping equations). Then the jumps are system specific information that is cached.

[isaacsas]

That might tie in better with letting users specify jump-equations using Poisson processes as a long-term goal (where the equations are then analyzed to pull out the underlying individual jumps that are cached).

[ChrisRackauckas]

Not all systems always do the same thing. How would you dispatch between them?

[shashi]

How would you dispatch between them?

struct System{T}
    systemparams::T

[shashi]

You can dispatch on T

For example T could be ODE() or SDE(noiseeqs)... It's the stuff that makes the particular kind of system special.

[ChrisRackauckas]

So half of the system quantities would be non-field like fields? That seems really weird.

[shashi]

Ok but it seems to me like at least

    states::Vector
    parameters::Vector
    pins::Vector
    observed::Vector
    systems::Vector
    name::Symbol
    cache::Dict # this is a convenience
    # (I've deleted `eqs` and `iv`)

form a common component infrastructure. If you were to draw wiring diagrams of systems then this is the minimal thing that you'd need to represent the inputs outputs and interactions. Anything else would be "internal details" within each box, so it makes sense to me to have those parameters in another struct inside the System struct.

[ChrisRackauckas]

This seems like one of the few cases where abstract inheritance via a macro makes sense.