ODESystem

struct ODESystem <: ModelingToolkit.AbstractODESystem

A system of ordinary differential equations.

Fields

• tag: A tag for the system. If two systems have the same tag, then they are structurally identical.

• eqs: The ODEs defining the system.

• iv: Independent variable.

• states: Dependent (state) variables. Must not contain the independent variable.

  N.B.: If torn_matching !== nothing, this includes all variables. Actual ODE states are determined by the SelectedState() entries in torn_matching.

• ps: Parameter variables. Must not contain the independent variable.

• tspan: Time span.

• var_to_name: Array variables.

• ctrls: Control parameters (some subset of ps).

• observed: Observed states.

• tgrad: Time-derivative matrix. Note: this field will not be defined until calculate_tgrad is called on the system.

• jac: Jacobian matrix. Note: this field will not be defined until calculate_jacobian is called on the system.

• ctrl_jac: Control Jacobian matrix. Note: this field will not be defined until calculate_control_jacobian is called on the system.

• Wfact: Note: this field will not be defined until generate_factorized_W is called on the system.

• Wfact_t: Note: this field will not be defined until generate_factorized_W is called on the system.

• name: The name of the system.

• systems: The internal systems. These are required to have unique names.

• defaults: The default values to use when initial conditions and/or parameters are not supplied in ODEProblem.

• torn_matching: Tearing result specifying how to solve the system.

• connector_type: Type of the system.

• preface: Inject assignment statements before the evaluation of the RHS function.

• continuous_events: A Vector{SymbolicContinuousCallback} that model events. The integrator will use root finding to guarantee that it steps at each zero crossing.

• discrete_events: A Vector{SymbolicDiscreteCallback} that models events. Symbolic analog to SciMLBase.DiscreteCallback that executes an affect when a given condition is true at the end of an integration step.

• metadata: Metadata for the system, to be used by downstream packages.

• gui_metadata: Metadata for MTK GUI.

• tearing_state: Cache for intermediate tearing state.

• substitutions: Substitutions generated by tearing.

• complete: If a model sys is complete, then sys.x no longer performs namespacing.

• discrete_subsystems: A list of discrete subsystems.

• unknown_states: A list of actual states needed to be solved by solvers. Only used for ODAEProblem.

• split_idxs: A vector of vectors of indices for the split parameters.

• parent: The hierarchical parent system before simplification.

Example

using ModelingToolkit

@parameters σ ρ β
@variables t x(t) y(t) z(t)
D = Differential(t)

eqs = [D(x) ~ σ*(y-x),
       D(y) ~ x*(ρ-z)-y,
       D(z) ~ x*y - β*z]

@named de = ODESystem(eqs,t,[x,y,z],[σ,ρ,β],tspan=(0, 1000.0))

structural_simplify(sys; ...)
structural_simplify(sys, io; simplify, kwargs...)

Structurally simplify algebraic equations in a system and compute the topological sort of the observed equations. When simplify=true, the simplify function will be applied during the tearing process. It also takes kwargs allow_symbolic=false and allow_parameter=true which limits the coefficient types during tearing.

The optional argument io may take a tuple (inputs, outputs). This will convert all inputs to parameters and allow them to be unconnected, i.e., simplification will allow models where n_states = n_equations - n_inputs.

ode_order_lowering(sys::ODESystem) -> Any

Takes a Nth order ODESystem and returns a new ODESystem written in first order form by defining new variables which represent the N-1 derivatives.

dae_index_lowering(sys::ODESystem; kwargs...) -> ODESystem

Perform the Pantelides algorithm to transform a higher index DAE to an index 1 DAE. kwargs are forwarded to pantelides!. End users are encouraged to call structural_simplify instead, which calls this function internally.

liouville_transform(sys::ModelingToolkit.AbstractODESystem)

Generates the Liouville transformed set of ODEs, which is the original ODE system with a new variable trJ appended, corresponding to the -tr(Jacobian). This variable is used for properties like uncertainty propagation from a given initial distribution density.

For example, if $u'=p*u$ and p follows a probability distribution $f(p)$, then the probability density of a future value with a given choice of $p$ is computed by setting the initial trJ = f(p), and the final value of trJ is the probability of $u(t)$.

Example:

using ModelingToolkit, OrdinaryDiffEq, Test

@parameters t α β γ δ
@variables x(t) y(t)
D = Differential(t)

eqs = [D(x) ~ α*x - β*x*y,
       D(y) ~ -δ*y + γ*x*y]

sys = ODESystem(eqs)
sys2 = liouville_transform(sys)
@variables trJ

u0 = [x => 1.0,
      y => 1.0,
      trJ => 1.0]

prob = ODEProblem(sys2,u0,tspan,p)
sol = solve(prob,Tsit5())

Where sol[3,:] is the evolution of trJ over time.

Sources:

Probabilistic Robustness Analysis of F-16 Controller Performance: An Optimal Transport Approach

Abhishek Halder, Kooktae Lee, and Raktim Bhattacharya https://abhishekhalder.bitbucket.io/F16ACC2013Final.pdf

tearing(sys; simplify=false)

Tear the nonlinear equations in system. When simplify=true, we simplify the new residual equations after tearing. End users are encouraged to call structural_simplify instead, which calls this function internally.

calculate_jacobian(sys::AbstractSystem)

Calculate the Jacobian matrix of a system.

Returns a matrix of Num instances. The result from the first call will be cached in the system object.

calculate_tgrad(sys::AbstractTimeDependentSystem)

Calculate the time gradient of a system.

Returns a vector of Num instances. The result from the first call will be cached in the system object.

calculate_factorized_W(sys::AbstractSystem)

Calculate the factorized W-matrix of a system.

Returns a matrix of Num instances. The result from the first call will be cached in the system object.

generate_jacobian(sys::AbstractSystem, dvs = states(sys), ps = parameters(sys),
                  expression = Val{true}; sparse = false, kwargs...)

Generates a function for the Jacobian matrix of a system. Extra arguments control the arguments to the internal build_function call.

generate_tgrad(sys::AbstractTimeDependentSystem, dvs = states(sys), ps = parameters(sys),
               expression = Val{true}; kwargs...)

Generates a function for the time gradient of a system. Extra arguments control the arguments to the internal build_function call.

generate_factorized_W(sys::AbstractSystem, dvs = states(sys), ps = parameters(sys),
                      expression = Val{true}; sparse = false, kwargs...)

Generates a function for the factorized W matrix of a system. Extra arguments control the arguments to the internal build_function call.

DiffEqBase.ODEFunction{iip}(sys::AbstractODESystem, dvs = states(sys),
                            ps = parameters(sys);
                            version = nothing, tgrad = false,
                            jac = false,
                            sparse = false,
                            kwargs...) where {iip}

Create an ODEFunction from the ODESystem. The arguments dvs and ps are used to set the order of the dependent variable and parameter vectors, respectively.

DiffEqBase.ODEProblem{iip}(sys::AbstractODESystem, u0map, tspan,
                           parammap = DiffEqBase.NullParameters();
                           version = nothing, tgrad = false,
                           jac = false,
                           checkbounds = false, sparse = false,
                           simplify = false,
                           linenumbers = true, parallel = SerialForm(),
                           kwargs...) where {iip}

Generates an ODEProblem from an ODESystem and allows for automatically symbolically calculating numerical enhancements.

SciMLBase.SteadyStateProblem(sys::AbstractODESystem, u0map,
                             parammap = DiffEqBase.NullParameters();
                             version = nothing, tgrad = false,
                             jac = false,
                             checkbounds = false, sparse = false,
                             linenumbers = true, parallel = SerialForm(),
                             kwargs...) where {iip}

Generates an SteadyStateProblem from an ODESystem and allows for automatically symbolically calculating numerical enhancements.

ODAEProblem{iip}(sys, u0map, tspan, parammap = DiffEqBase.NullParameters(); kw...)

This constructor acts similar to the one for ODEProblem with the following changes: ODESystems can sometimes be further reduced if structural_simplify has already been applied to them. In these cases, the constructor uses the knowledge of the strongly connected components calculated during the process of simplification as the basis for building pre-simplified nonlinear systems in the implicit solving.

In summary: these problems are structurally modified, but could be more efficient and more stable. Note, the returned object is still of type ODEProblem.

ODEFunctionExpr{iip}(sys::AbstractODESystem, dvs = states(sys),
                     ps = parameters(sys);
                     version = nothing, tgrad = false,
                     jac = false,
                     sparse = false,
                     kwargs...) where {iip}

Create a Julia expression for an ODEFunction from the ODESystem. The arguments dvs and ps are used to set the order of the dependent variable and parameter vectors, respectively.

DAEFunctionExpr{iip}(sys::AbstractODESystem, dvs = states(sys),
                     ps = parameters(sys);
                     version = nothing, tgrad = false,
                     jac = false,
                     sparse = false,
                     kwargs...) where {iip}

Create a Julia expression for an ODEFunction from the ODESystem. The arguments dvs and ps are used to set the order of the dependent variable and parameter vectors, respectively.

SciMLBase.SteadyStateProblemExpr(sys::AbstractODESystem, u0map,
                                 parammap = DiffEqBase.NullParameters();
                                 version = nothing, tgrad = false,
                                 jac = false,
                                 checkbounds = false, sparse = false,
                                 skipzeros = true, fillzeros = true,
                                 linenumbers = true, parallel = SerialForm(),
                                 kwargs...) where {iip}

Generates a Julia expression for building a SteadyStateProblem from an ODESystem and allows for automatically symbolically calculating numerical enhancements.