RODESystem

Construction of RODESystem

A RODESystem is represented by the state function

and the output function

where $t$ is the time, $x \in R^n$ is the state, $u \in R^p$ and $y \in R^m$ is output of the system. Therefore to construct a RODESystem, we need to define statefunc and outputfunc with the corresponding syntax,

function statefunc(dx, x, u, t)
    dx .= ... # Update dx 
end

and

function outputfunc(x, u, t)
    y = ... # Compute y
    return y
end

As an example, consider the system with the state function

and with the output function

That is, all the state variable are taken as output. The statefunc and the outputfunc is defined as,

julia> function statefunc(dx, x, u, t, W)
           dx[1] = 2x[1]*sin(W[1] - W[2])
           dx[2] = -2x[2]*cos(W[1] + W[2])
       end
statefunc (generic function with 1 method)

julia> outputfunc(x, u, t) = x
outputfunc (generic function with 1 method)

To construct the RODESystem, we need to specify the initial condition and time.

julia> x0 = [1., 1.]
2-element Array{Float64,1}:
 1.0
 1.0

julia> t = 0.
0.0

Note from statefunc, the system has not any input, i.e. input is nothing, and has an output with a dimension of 1.

julia> input = nothing

julia> output = Bus(2)
2-element Bus{Link{Float64}}:
 Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)
 Link(state:open, eltype:Float64, hasmaster:false, numslaves:0, isreadable:false, iswritable:false)

We are ready to construct the system

julia> ds = RODESystem(input, output, statefunc, outputfunc, x0, t)
ERROR: Fixed timestep methods require a choice of dt or choosing the tstops

Note that ds has a solver to solve its state function statefunc which is random differential equation. To solve its statefunc, the step size of the solver must be specified. See Random Differential Equtions of DifferentialEquations package.

julia> ds.solver.params[:dt] = 1 / 100
ERROR: UndefVarError: ds not defined

Basic Operation of RODESystem

When a RODESystem is triggered from its trigger link, it read the current time from its trigger link, reads its input (if available, i.e. its input is not nothing), solves its state function, computes its output value and writes its output value its output bus (again, if available, i.e., its output bus is not nothing). To drive a RODESystem, it must be launched. Let us continue with ds constructed in the previous section.

julia> task = launch(ds)
ERROR: UndefVarError: ds not defined

When launched, ds is ready to be driven. We can drive ds by drive(ds, t) or put!(ds.trigger, t) where t is the time until which we will drive ds.

julia> drive(ds, 1.)
ERROR: UndefVarError: ds not defined

When triggered, ds read the time t from its trigger link, solved its differential equation, computed its value and writes its output value to its output bus. To signal that, the evolution is succeeded, ds writes true to its handshake link which must be taken to further drive ds. (approve(ds)) can also be used.

julia> take!(ds.handshake)
ERROR: UndefVarError: ds not defined

We can continue to drive ds.

julia> for t in 2. : 10.
           put!(ds.trigger, t)
           take!(ds.handshake)
       end
ERROR: UndefVarError: ds not defined

After each evolution, ds writes its current output value to its output bus.

julia> [ds.output[1].buffer.data ds.output[2].buffer.data]
ERROR: UndefVarError: ds not defined

When launched, a task was constructed which still running. As long as no exception is thrown during the evolution of ds, the state of task is running which implies ds can be driven.

julia> task
ERROR: UndefVarError: task not defined

To terminate the task safely, ds should be terminated safely.

julia> terminate(ds)
ERROR: UndefVarError: ds not defined

Note that the state of task is done which implies the task has been terminated safely.

julia> task
ERROR: UndefVarError: task not defined

Full API

RODESystem(input, output, statefunc, outputfunc, state, t, modelargs=(), solverargs=(); 
    alg=RODEAlg, modelkwargs=NamedTuple(), solverkwargs=NamedTuple())

function statefunc(dx, x, u, t, W)
    dx .= ... # Update dx 
end

function outputfunc(x, u, t)
    y = ... # Compute y
    return y
end

julia> function statefunc(dx, x, u, t, W)
         dx[1] = 2x[1]*sin(W[1] - W[2])
         dx[2] = -2x[2]*cos(W[1] + W[2])
       end;

julia> outputfunc(x, u, t) = x;

julia> ds = RODESystem(nothing, Bus(2), statefunc, outputfunc, [1., 1.], 0., solverkwargs=(dt=0.01,))
RODESystem(state:[1.0, 1.0], t:0.0, input:nothing, output:Bus(nlinks:2, eltype:Link{Float64}, isreadable:false, iswritable:false))