ModelingToolkit.jl

https://docs.sciml.ai/ModelingToolkit/stable/
Admin
ModelingToolkit.jl is a symbolic-numeric modeling language for high-performance equation-based...
Tokens:226,583
Snippets:2,050
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example: System definition and parameter setup

Source: https://docs.sciml.ai/ModelingToolkit/stable/basics/FAQ

Demonstrates how to define a system with parameters, including arrays, and then complete the system. This setup is necessary before working with tunable parameters and their ordering.

```julia
using ModelingToolkit

@parameters p q[1:3] r[1:2, 1:2]

@named sys = System(Equation[], ModelingToolkit.t_nounits, [], [p, q, r])
sys = complete(sys)
```

--------------------------------

### Default parameter handling in callbacks

Source: https://docs.sciml.ai/ModelingToolkit/stable/basics/Events

This example shows a system setup with variables and parameters, and a basic event. By default, unknowns are modifiable, parameters are not, and other variables adjust to maintain consistency.

```julia
@variables x(t) y(t)
@parameters p(t)
@mtkcompile sys = System([x * y ~ p, D(x) ~ 0], t)
event = [t == 1] => [x ~ Pre(x) + 1]
```

--------------------------------

### AttractorSeedContinueMatch Initialization Example

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/attractors

This is a detailed example of initializing AttractorSeedContinueMatch with a complex configuration, including dynamical systems, ODE integrators, and problem definitions. It showcases the extensive setup required for advanced simulations.

```julia
Attractors.AttractorSeedContinueMatch{Attractors.AttractorsViaRecurrences{DynamicalSystemsBase.CoupledODEs{true, 3, OrdinaryDiffEqCore.ODEIntegrator{OrdinaryDiffEqTsit5.Tsit5{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}, true, Vector{Float64}, Nothing, Float64, MTKParameters{Vector{Float64}, Vector{Float64}, Tuple{}, Tuple{}, Tuple{}, Tuple{}}, Float64, Float64, Float64, Float64, Vector{Vector{Float64}}, SciMLBase.ODESolution{Float64, 2, Vector{Vector{Float64}}, Nothing, Nothing, Vector{Float64}, Vector{Vector{Vector{Float64}}}, Nothing, ODEProblem{Vector{Float64}, Tuple{Float64, Float64}, true, MTKParameters{Vector{Float64}, Vector{Float64}, Tuple{}, Tuple{}, Tuple{}, Tuple{}}, ODEFunction{true, SciMLBase.AutoSpecialize, ModelingToolkitBase.GeneratedFunctionWrapper{(2, 3, true), RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:___mtkunknowns___, :___mtkparameters___, :__argₛᵧₘ12580101548712062751), ModelingToolkitBase.var"#_RGF_ModTag", ModelingToolkitBase.var"#_RGF_ModTag", (0x59a205e3, 0xf48fec9d, 0x4c98a910, 0x34ec3f2d, 0x3f31dd7f), Nothing}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:__argₛᵧₘ1401282876548370056, :___mtkunknowns___, :___mtkparameters___, :__argₛᵧₘ12580101548712062751), ModelingToolkitBase.var"#_RGF_ModTag", ModelingToolkitBase.var"#_RGF_ModTag", (0x51d518b6, 0xed1ed485, 0xce6f816f, 0xf500058a, 0xc8558994), Nothing}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, ModelingToolkitBase.ObservedFunctionCache{System, Nothing}, Nothing, System, Union{Nothing, SciMLBase.OverrideInitData}, Union{Nothing, SciMLBase.ODENLStepData}}, Base.Pairs{Symbol, Union{}, Tuple{}, @NamedTuple{}}, SciMLBase.StandardODEProblem}, OrdinaryDiffEqTsit5.Tsit5{typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}, OrdinaryDiffEqCore.InterpolationData{ODEFunction{true, SciMLBase.AutoSpecialize, ModelingToolkitBase.GeneratedFunctionWrapper{(2, 3, true), RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:___mtkunknowns___, :___mtkparameters___, :__argₛᵧₘ12580101548712062751), ModelingToolkitBase.var"#_RGF_ModTag", ModelingToolkitBase.var"#_RGF_ModTag", (0x59a205e3, 0xf48fec9d, 0x4c98a910, 0x34ec3f2d, 0x3f31dd7f), Nothing}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:__argₛᵧₘ1401282876548370056, :___mtkunknowns___, :___mtkparameters___, :__argₛᵧₘ12580101548712062751), ModelingToolkitBase.var"#_RGF_ModTag", ModelingToolkitBase.var"#_RGF_ModTag", (0x51d518b6, 0xed1ed485, 0xce6f816f, 0xf500058a, 0xc8558994), Nothing}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, ModelingToolkitBase.ObservedFunctionCache{System, Nothing}, Nothing, System, Union{Nothing, SciMLBase.OverrideInitData}, Union{Nothing, SciMLBase.ODENLStepData}}, Vector{Vector{Float64}}, Vector{Float64}, Vector{Vector{Vector{Float64}}}, Nothing, OrdinaryDiffEqTsit5.Tsit5Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}, Nothing}, SciMLBase.DEStats, Nothing, Nothing, Nothing, Nothing}, ODEFunction{true, SciMLBase.AutoSpecialize, ModelingToolkitBase.GeneratedFunctionWrapper{(2, 3, true), RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:___mtkunknowns___, :___mtkparameters___, :__argₛᵧₘ12580101548712062751), ModelingToolkitBase.var"#_RGF_ModTag", ModelingToolkitBase.var"#_RGF_ModTag", (0x59a205e3, 0xf48fec9d, 0x4c98a910, 0x34ec3f2d, 0x3f31dd7f), Nothing}, RuntimeGeneratedFunctions.RuntimeGeneratedFunction{(:__argₛᵧₘ1401282876548370056, :___mtkunknowns___, :___mtkparameters___, :__argₛᵧₘ12580101548712062751), ModelingToolkitBase.var"#_RGF_ModTag", ModelingToolkitBase.var"#_RGF_ModTag", (0x51d518b6, 0xed1ed485, 0xce6f816f, 0xf500058a, 0xc8558994), Nothing}}, LinearAlgebra.UniformScaling{Bool}, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, Nothing, ModelingToolkitBase.ObservedFunctionCache{System, Nothing}, Nothing, System, Union{Nothing, SciMLBase.OverrideInitData}, Union{Nothing, SciMLBase.ODENLStepData}}, OrdinaryDiffEqTsit5.Tsit5Cache{Vector{Float64}, Vector{Float64}, Vector{Float64}, typeof(OrdinaryDiffEqCore.trivial_limiter!), typeof(OrdinaryDiffEqCore.trivial_limiter!), Static.False}, OrdinaryDiffEqCore.DEOptions{Float64, Float64, Float64, Float64, OrdinaryDiffEqCore.PIController{Float64}, typeof(DiffEqBase.ODE_DEFAULT_NORM), typeof(LinearAlgebra.opnorm), Bool, SciMLBase.CallbackSe
```

--------------------------------

### Complete Example for Precompilation-Friendly Component

Source: https://docs.sciml.ai/ModelingToolkit/stable/basics/PrecompileComponents

This example demonstrates a complete, type-stable component definition suitable for precompilation in ModelingToolkit.jl.

```julia
using ModelingToolkit
using PrecompileTools

function build_my_component()
    @variables sys(t)[1:2]
    @parameters sys[1:2]
    vars = SymbolicT[]
    params = SymbolicT[]
    push!(vars, sys(t)[1])
    push!(vars, sys(t)[2])
    push!(params, sys[1])
    push!(params, sys[2])

    initial_conditions = Dict{SymbolicT, SymbolicT}()
    guesses = Dict{SymbolicT, SymbolicT}()
    initial_conditions[vars[1]] = 1.0
    guesses[vars[1]] = 1.0

    eqs = Equation[]
    push!(eqs, vars[1] ~ params[1])
    push!(eqs, vars[2] ~ params[2])

    subsystems = Vector{System}()

    return System(eqs, t, vars, params; initializers=initial_conditions, guesses=guesses, systems=subsystems)
end

# Example usage:
# my_component = build_my_component()
# @compile_workload begin
#     build_my_component()
# end
```

--------------------------------

### Precompilation Example Module

Source: https://docs.sciml.ai/ModelingToolkit/stable/basics/Precompilation

This example demonstrates a complete module structure that effectively utilizes precompilation for an ODE system. It defines a system, compiles it, and creates an ODE problem with precompilation-friendly options.

```julia
module PrecompilationMWE
using ModelingToolkit

@variables x(ModelingToolkit.t_nounits)
@named sys = System([ModelingToolkit.D_nounits(x) ~ -x + 1], ModelingToolkit.t_nounits)
prob = ODEProblem(mtkcompile(sys), [x => 30.0], (0, 100), [],
    eval_expression = true, eval_module = @__MODULE__)

end
```

--------------------------------

### System with a Restrictor Component (Initial)

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/domain_connections

An example system that includes the Restrictor component. Without explicit domain connection, this setup can cause a break in the domain network.

```julia
@component function RestrictorSystem(; name)
    systems = @named begin
        src = FixedPressure(; p = 200e5)
        res = Restrictor(; p_int = 200e5)
        vol = FixedVolume(; vol = 0.1, p_int = 200e5)

        fluid = HydraulicFluid(; density = 876)
    end

    eqs = [connect(fluid, src.port)
           connect(src.port, res.port_a)
           connect(res.port_b, vol.port)]

    System(eqs, t, [], []; systems, name)
end

@mtkcompile ressys = RestrictorSystem()
```

--------------------------------

### Example: Linearizing a Feedback Interconnection

Source: https://docs.sciml.ai/ModelingToolkit/stable/basics/Linearization

This example demonstrates how to build a feedback system using `ModelingToolkit` and then linearize it. It defines a plant, a reference filter, and a controller, connects them, and then linearizes the closed-loop system around a specified operating point. The resulting state-space matrices (A, B, C, D) are asserted.

```julia
using ModelingToolkit
using ModelingToolkit: t_nounits as t, D_nounits as D
function plant(; name)
    @variables x(t) = 1
    @variables u(t)=0 y(t)=0
    eqs = [D(x) ~ -x + u
           y ~ x]
    System(eqs, t; name = name)
end

function ref_filt(; name)
    @variables x(t)=0 y(t)=0
    @variables u(t)=0 [input = true]
    eqs = [D(x) ~ -2 * x + u
           y ~ x]
    System(eqs, t, name = name)
end

function controller(kp; name)
    @variables y(t)=0 r(t)=0 u(t)=0
    @parameters kp = kp
    eqs = [
        u ~ kp * (r - y),
    ]
    System(eqs, t; name = name)
end

@named f = ref_filt()
@named c = controller(1)
@named p = plant()

connections = [f.y ~ c.r # filtered reference to controller reference
               c.u ~ p.u # controller output to plant input
               p.y ~ c.y]

@named cl = System(connections, t, systems = [f, c, p])

lsys0, ssys = linearize(cl, [f.u], [p.x])
desired_order = [f.x, p.x]
lsys = ModelingToolkit.reorder_unknowns(lsys0, unknowns(ssys), desired_order)

@assert lsys.A == [-2 0; 1 -2]
@assert lsys.B == [1; 0;;]
@assert lsys.C == [0 1]
@assert lsys.D[] == 0

```

--------------------------------

### Girsanov Transform and SDEProblem Setup

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/model_building

Demonstrates setting up an SDEProblem with a Girsanov transform and an EnsembleProblem for simulations.

```julia
u = x
θ0 = 0.1
g(x) = x[1]^2
demod = ModelingToolkitBase.Girsanov_transform(de, u; θ0=0.1)

u0modmap = [
x => x0
]

parammap = [
    α => 1.5,
    β => 1.0
]

probmod = SDEProblem(complete(demod),u0modmap,(0.0,1.0),parammap)
ensemble_probmod = EnsembleProblem(probmod;
          output_func = (sol,i) -> (g(sol[x,end])*sol[demod.weight,end],false),
          )

simmod = solve(ensemble_probmod,EM(),dt=dt,trajectories=numtraj)
```

--------------------------------

### Component Library Setup

Source: https://docs.sciml.ai/ModelingToolkit/stable/examples/tearing_parallelism

Imports necessary libraries and defines time and derivative variables for system modeling.

```julia
using ModelingToolkit, OrdinaryDiffEq
using ModelingToolkit: t_nounits as t, D_nounits as D

```

--------------------------------

### Shift Operator Example

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/variables

Demonstrates the creation and usage of the Shift operator from ModelingToolkitBase.

```julia
using Symbolics

Δ = Shift(t)
```

--------------------------------

### PDESystem Constructor Example

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/PDESystem

Demonstrates how to construct a PDESystem for a 2D wave equation with initial and boundary conditions. This system can then be discretized for numerical solving.

```julia
using ModelingToolkit

@parameters x t
@variables u(..)
Dxx = Differential(x)^2
Dtt = Differential(t)^2
Dt = Differential(t)

#2D PDE
C=1
eq  = Dtt(u(t,x)) ~ C^2*Dxx(u(t,x))

# Initial and boundary conditions
bcs = [u(t,0) ~ 0.,# for all t > 0
       u(t,1) ~ 0.,# for all t > 0
       u(0,x) ~ x*(1. - x), #for all 0 < x < 1
       Dt(u(0,x)) ~ 0. ] #for all  0 < x < 1]

# Space and time domains
domains = [t ∈ (0.0,1.0),
           x ∈ (0.0,1.0)]

@named pde_system = PDESystem(eq,bcs,domains,[t,x],[u])
```

--------------------------------

### Get System Description (ModelingToolkitBase)

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Obtains the description associated with the system, returning an empty string if none is present.

```julia
description(sys::ModelingToolkitBase.AbstractSystem) -> Any
```

--------------------------------

### Complete Lotka-Volterra component example

Source: https://docs.sciml.ai/ModelingToolkit/stable/basics/PrecompileComponents

A complete component definition demonstrating the recommended practices for building variables, parameters, initial conditions, guesses, and equations for optimized precompilation.

```julia
using ModelingToolkit
using ModelingToolkit: SymbolicT

@component function LotkaVolterra(; 
        name, α = 1.3, β = 0.9, γ = 0.8, δ = 1.8)
    @parameters begin
        α = α
        β = β
        γ = γ
        δ = δ
    end
    params = SymbolicT[]
    push!(params, α)
    push!(params, β)
    push!(params, γ)
    push!(params, δ)

    @variables begin
        x(t_nounits)
        y(t_nounits)
    end
    vars = SymbolicT[]
    push!(vars, x)
    push!(vars, y)

    initial_conditions = Dict{SymbolicT, SymbolicT}()
    push!(initial_conditions, x => 3.1)
    push!(initial_conditions, y => 1.5)

    guesses = Dict{SymbolicT, SymbolicT}()

    eqs = Equation[]
    push!(eqs, D_nounits(x) ~ α * x - β * x * y)
    push!(eqs, D_nounits(y) ~ -δ * y + γ * x * y)

    return System(eqs, t_nounits, vars, params;
        systems = System[], initial_conditions, guesses, name)
end
```

--------------------------------

### Get Symbolic Time Stops

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the tstops present in the system and its subsystems, appropriately namespaced.

```julia
symbolic_tstops(
    sys::ModelingToolkitBase.AbstractSystem
) -> Any
```

--------------------------------

### Get all brownians

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get all of the brownian variables involved in the system `sys` and all subsystems, appropriately namespaced.

```julia
brownians(sys::ModelingToolkitBase.AbstractSystem) -> Any
```

--------------------------------

### Get all parameters

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the parameters of the system `sys` and its subsystems. See also `@parameters` and `ModelingToolkitBase.get_ps`.

```julia
parameters(
    sys::ModelingToolkitBase.AbstractSystem;
    initial_parameters
) -> Vector{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)" {SymReal}}
```

--------------------------------

### Get InitializeSystem Field

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the internal field 'initializesystem' of a system. It only includes 'initializesystem' local to the system.

```julia
ModelingToolkitBase.get_initializesystem(
    sys::ModelingToolkitBase.AbstractSystem
) -> Any
```

--------------------------------

### Get Parent Field

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the internal field 'parent' of a system. It only includes 'parent' local to the system.

```julia
ModelingToolkitBase.get_parent(sys::ModelingToolkitBase.AbstractSystem) -> Any
```

--------------------------------

### Example: Canonicalizing and accessing tunable parameters

Source: https://docs.sciml.ai/ModelingToolkit/stable/basics/FAQ

Shows how to create an `MTKParameters` object, canonicalize it to extract the tunable parameters into a flat array (`arr`), and observe their default ordering.

```julia
using SciMLStructures: canonicalize, Tunable

ps = MTKParameters(sys, [p => 1.0, q => [2.0, 3.0, 4.0], r => [5.0 6.0; 7.0 8.0]])
arr = canonicalize(Tunable(), ps)[1]
```

--------------------------------

### Get Preface Field

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the internal field 'preface' of a system. It only includes 'preface' local to the system.

```julia
ModelingToolkitBase.get_preface(sys::ModelingToolkitBase.AbstractSystem) -> Any
```

--------------------------------

### Get Tearing State Field

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the internal field 'tearing_state' of a system. It only includes 'tearing_state' local to the system.

```julia
ModelingToolkitBase.get_tearing_state(
    sys::ModelingToolkitBase.AbstractSystem
) -> Any
```

--------------------------------

### Constructing ODEProblem with System Defaults

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/initialization

This example shows how to create an ODEProblem using a system that has default initial conditions. It highlights a potential warning for overdetermined systems.

```julia
julia> tspan = (0.0, 1.0)
julia> ODEProblem(sys, [], tspan) # fine
┌ Warning: Initialization system is overdetermined. 2 equations for 1 unknowns. Initialization will default to using least squares. `SCCNonlinearProblem` can only be used for initialization of fully determined systems and hence will not be used here.
│ 
│ 
│ To suppress this warning, pass `warn_initialize_determined = false`. To turn this warning into an error, pass `fully_determined = true`.
└ @ ModelingToolkit ~/work/ModelingToolkit.jl/ModelingToolkit.jl/src/initialization.jl:22
ODEProblem with uType Vector{Float64} and tType Float64. In-place: true
Initialization status: FULLY_DETERMINED
Non-trivial mass matrix: false
timespan: (0.0, 1.0)
u0: 1-element Vector{Float64}:
 2.0
```

--------------------------------

### Get Time Stops Field

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the internal field 'tstops' of a system. It only includes 'tstops' local to the system.

```julia
ModelingToolkitBase.get_tstops(sys::ModelingToolkitBase.AbstractSystem) -> Any
```

--------------------------------

### Compiling and Solving a Composed System

Source: https://docs.sciml.ai/ModelingToolkit/stable/basics/Composition

This snippet demonstrates compiling the composed 'sir' system into a simplified form 'sireqn_simple' and then solving the resulting ODE problem. It shows how to define initial conditions, parameters, and the time span for the simulation.

```julia
sireqn_simple = mtkcompile(sir)

equations(sireqn_simple)
```
3-element Vector{Equation}:
 Differential(t, 1)(ieqn₊S(t)) ~ (seqn₊β*ieqn₊S(t)*ieqn₊I(t)) / (-ieqn₊S(t) - ieqn₊R(t) - ieqn₊I(t))
 Differential(t, 1)(ieqn₊R(t)) ~ reqn₊γ*ieqn₊I(t)
 Differential(t, 1)(ieqn₊I(t)) ~ (ieqn₊β*ieqn₊S(t)*ieqn₊I(t)) / (ieqn₊S(t) + ieqn₊R(t) + ieqn₊I(t)) - ieqn₊γ*ieqn₊I(t)
```

## User Code

u0 = [seqn.S => 990.0,
    ieqn.I => 10.0,
    reqn.R => 0.0]


p = [β => 0.5
     γ => 0.25]

tspan = (0.0, 40.0)
prob = ODEProblem(sireqn_simple, u0, tspan, p, jac = true)
sol = solve(prob, Tsit5())
sol[reqn.R]

```

--------------------------------

### Constructing a BVProblem with SciMLBase

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/problems

Demonstrates the construction of a `SciMLBase.BVProblem` using a compiled `System` (pendulum example). It shows how to define the system, time span, initial conditions, parameters, and guesses for the boundary value problem.

```julia
using SciMLBase
using ModelingToolkit

@parameters g t_c = 0.5
@variables x(..) y(t) λ(t)
eqs = [
    D(D(x(t))) ~ λ * x(t)
    D(D(y)) ~ λ * y - g
    x(t)^2 + y^2 ~ 1
]
cstr = [x(0.5) ~ 1]
@mtkcompile pend = System(eqs, t; constraints = cstr)

tspan = (0.0, 1.5)
u0map = [x(t) => 0.6, y => 0.8]
parammap = [g => 1]
guesses = [λ => 1]

bvp = SciMLBase.BVProblem{true, SciMLBase.AutoSpecialize}(pend, u0map, tspan, parammap; guesses, check_length = false)
```

--------------------------------

### Get DDE System Field

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the internal field 'is_dde' of a system. It only includes 'is_dde' local to the system.

```julia
ModelingToolkitBase.get_is_dde(sys::ModelingToolkitBase.AbstractSystem) -> Any
```

--------------------------------

### Simulate and Plot a Model with Disturbance

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/disturbance_modeling

Instantiates the ModelWithInputs, compiles it, sets up an ODE problem, solves it, and plots the simulation results. This demonstrates a full simulation workflow.

```julia
@named model = ModelWithInputs() # Model with load disturbance
ssys = mtkcompile(model)
prob = ODEProblem(ssys, [], (0.0, 6.0))
sol = solve(prob, Tsit5())
using Plots
plot(sol)
```

--------------------------------

### Define Initial Conditions and Parameters for a Composed System

Source: https://docs.sciml.ai/ModelingToolkit/stable/basics/Composition

Sets up the initial conditions and parameters for a simplified system. These are then used to create an ODEProblem for numerical solving.

```julia
x0 = [
      decay1.x => 1.0
      decay1.f => 0.0
      decay2.x => 1.0
]
p = [
      decay1.a => 0.1
      decay2.a => 0.2
]

using OrdinaryDiffEq
prob = ODEProblem(simplified_sys, [x0; p], (0.0, 100.0))
sol = solve(prob, Tsit5())
sol[decay2.f]
```

--------------------------------

### Install ModelingToolkit.jl

Source: https://docs.sciml.ai/ModelingToolkit/stable

Use the Julia package manager to add ModelingToolkit.jl to your project. This is the standard way to install Julia packages.

```julia
using Pkg
Pkg.add("ModelingToolkit")
```

--------------------------------

### Get brownians field

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the internal field `brownians` of a system `sys`. It only includes `brownians` local to `sys`; not those of its subsystems. See also `has_brownians`.

```julia
get_brownians(
    sys::ModelingToolkitBase.AbstractSystem
) -> Any
```

--------------------------------

### Simplified ODE System Example

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/ode_modeling

Defines, compiles, and solves a simple ODE system, then plots the solution. Requires ModelingToolkit and OrdinaryDiffEq packages.

```julia
using ModelingToolkit
using ModelingToolkit: t_nounits as t, D_nounits as D

@parameters τ = 3.0 # parameters
@variables x(t) = 0.0 # dependent variables
eqs = [D(x) ~ (1 - x) / τ]

@named fol_model = System(eqs, t)

using OrdinaryDiffEq
fol = mtkcompile(fol_model)
prob = ODEProblem(fol, [], (0.0, 10.0))
sol = solve(prob)

using Plots
plot(sol)
```

--------------------------------

### initialization_equations

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/initialization

Retrieves the initialization equations for a given system and its subsystems.

```APIDOC
## Function `ModelingToolkitBase.initialization_equations`

### Description
Get the initialization equations of the system `sys` and its subsystems.

### Method
```julia
initialization_equations(
    sys::ModelingToolkitBase.AbstractSystem
) -> Any
```

### See Also
`guesses`, `initial_conditions`, and `ModelingToolkitBase.get_initialization_eqs`.
```

--------------------------------

### Get all unknowns

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the unknown variables of the system `sys` and its subsystems. These must be explicitly solved for, unlike `observables(sys)`. See also `ModelingToolkitBase.get_unknowns`.

```julia
unknowns(sys::ModelingToolkitBase.AbstractSystem) -> Any
```

--------------------------------

### Optimization Setup and Execution

Source: https://docs.sciml.ai/ModelingToolkit/stable/examples/remake

Sets up and executes an optimization problem using `Optimization.jl`. It defines an `OptimizationFunction` with automatic differentiation, initializes a `DiffCache` for performance, and solves the problem using the BFGS algorithm.

```julia
using Optimization
using OptimizationOptimJL
using SymbolicIndexingInterface

# manually create an OptimizationFunction to ensure usage of `ForwardDiff`, which will
# require changing the types of parameters from `Float64` to `ForwardDiff.Dual`
optfn = OptimizationFunction(loss, Optimization.AutoForwardDiff())
# function to set the parameters we are optimizing
setter = setp(odeprob, [α, β, γ, δ])
# `DiffCache` to avoid allocations.
# `copy` prevents the buffer stored by `DiffCache` from aliasing the one in
# `parameter_values(odeprob)`.
diffcache = DiffCache(copy(canonicalize(Tunable(), parameter_values(odeprob))[1]))
# parameter object is a tuple, to store differently typed objects together
optprob = OptimizationProblem(
    optfn, rand(4), (odeprob, timesteps, data, setter, diffcache),
    lb = 0.1zeros(4), ub = 3ones(4))
sol = solve(optprob, BFGS())

```

--------------------------------

### Get unknowns field

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the internal field `unknowns` of a system `sys`. It only includes `unknowns` local to `sys`; not those of its subsystems. See also `has_unknowns`.

```julia
get_unknowns(sys::ModelingToolkitBase.AbstractSystem) -> Any
```

--------------------------------

### Get consolidate field

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the internal field `consolidate` of a system `sys`. It only includes `consolidate` local to `sys`; not those of its subsystems. See also `has_consolidate`.

```julia
get_consolidate(
    sys::ModelingToolkitBase.AbstractSystem
) -> Any
```

--------------------------------

### Instantiate System Components

Source: https://docs.sciml.ai/ModelingToolkit/stable/examples/spring_mass

Initializes instances of the 'Mass' and 'Spring' components with specified physical properties like mass, initial position, spring constant, and rest length.

```julia
m = 1.0
xy = [1.0, -1.0]
k = 1e4
l = 1.0
center = [0.0, 0.0]
g = [0.0, -9.81]
@named mass = Mass(m = m, xy = xy)
@named spring = Spring(k = k, l = l)
```

--------------------------------

### Example Usage of @named Macro

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/model_building

This example demonstrates how the `@named` macro works with a simple function, showing how names are assigned and how array indexing is handled.

```julia
using ModelingToolkitBase

foo(i; name) = (; i, name)

x = 41

@named y = foo(x)
@named y[1:3] = foo(x)
```

--------------------------------

### Get parameters (ps) field

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the internal field `ps` of a system `sys`. It only includes `ps` local to `sys`; not those of its subsystems. See also `has_ps`.

```julia
get_ps(sys::ModelingToolkitBase.AbstractSystem) -> Any
```

--------------------------------

### Sample Operator Example

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/variables

Demonstrates the creation of a Sample operator, used for creating discrete-time signals by sampling continuous-time signals.

```julia
julia> using Symbolics

julia> t = ModelingToolkit.t_nounits

julia> Δ = Sample(0.01)
(::Sample) (generic function with 2 methods)
```

--------------------------------

### Create and Solve InfiniteOpt Dynamic Optimization Problem

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/dynamic_optimization

Sets up and solves a dynamic optimization problem using InfiniteOpt as the backend. The number of steps is specified, and a suitable optimizer (BackwardEuler with Ipopt) is recommended for free final time problems.

```julia
iprob = InfiniteOptDynamicOptProblem(block, [u0map; parammap], tspan; steps = 100)
isol = solve(iprob, InfiniteOptCollocation(Ipopt.Optimizer))
```

--------------------------------

### Get independent variable (iv) field

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Get the internal field `iv` of a system `sys`. It only includes `iv` local to `sys`; not those of its subsystems. See also `has_iv`.

```julia
get_iv(sys::ModelingToolkitBase.AbstractSystem) -> Any
```

--------------------------------

### Simulate System Model with Disturbance

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/disturbance_modeling

This snippet demonstrates how to compile, set up an ODE problem, and solve a system model that includes disturbance components. It uses `mtkcompile` and `ODEProblem` for simulation and includes a test to verify successful completion.

```julia
ssys = mtkcompile(model_with_disturbance)
prob = ODEProblem(ssys, [], (0.0, 10.0))
sol = solve(prob, Tsit5())
using Test
@test SciMLBase.successful_retcode(sol)
```

--------------------------------

### Warning Log Example

Source: https://docs.sciml.ai/ModelingToolkit/stable/basics/Debugging

Example of a warning log indicating a potential issue with time step stability during integration. It suggests checking the model specification or solution stability.

```julia
┌ Warning: Verbosity toggle: dt_min_unstable 
│  dt(0.1 <= dtmin(0.1), at t=0.4538820261379217, and step error estimate = NaN. Aborting. There is either an error in your model specification or the true solution is unstable.
└ @ SciMLBase ~/.julia/packages/SciMLBase/hLfdZ/src/integrator_interface.jl:717
```

--------------------------------

### get_initializesystem

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Retrieves the internal field `initializesystem` of a system.

```APIDOC
## get_initializesystem

### Description
Get the internal field `initializesystem` of a system `sys`. It only includes `initializesystem` local to `sys`; not those of its subsystems, like `unknowns(sys)`, `parameters(sys)` and `equations(sys)` does.

### Method
```julia
get_initializesystem(
    sys::ModelingToolkitBase.AbstractSystem
) -> Any
```

### See Also
`has_initializesystem`
```

--------------------------------

### Defining a System with Bindings and Initial Conditions

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/initialization

This snippet demonstrates how to define a system using ModelingToolkit, specifying both immutable bindings and initial conditions for variables and parameters.

```julia
using ModelingToolkit, Test
using ModelingToolkit: t_nounits as t, D_nounits as D

@variables x(t) y(t)
@parameters p q
@mtkcompile sys = System([D(x) ~ p * x + y, y ~ q * x], t; bindings = [y => x, q => 2p],
                         initial_conditions = [x => 1, p => 1])
```

--------------------------------

### Get Value for Possibly Indexed Key from AtomicArrayDict

Source: https://docs.sciml.ai/ModelingToolkit/stable/internals/systems

Retrieves a value from an AtomicArrayDict, similar to `get`. If the key is indexed, it attempts to access the specific element of the array; otherwise, it returns the default value.

```julia
get_possibly_indexed(
    dd::ModelingToolkitBase.AtomicArrayDict,
    k::SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymReal},
    default
) -> Any
```

--------------------------------

### Solve InitializationProblem using NonlinearSolve

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/initialization

Solve the created InitializationProblem using the `solve` function from NonlinearSolve.jl. This demonstrates how to find a solution for the initialization system.

```julia
using NonlinearSolve
sol = solve(iprob)
```

--------------------------------

### Example: Reordering a higher dimensional array

Source: https://docs.sciml.ai/ModelingToolkit/stable/basics/FAQ

Shows how `reorder_dimension_by_tunables` can be applied to higher-dimensional arrays by specifying the dimension (`dim = 2`) to be reordered. This example reorders the columns of a 5x8 matrix based on a mixed symbolic order.

```julia
highdimarr = stack([i * arr for i in 1:5]; dims = 1)
reorder_dimension_by_tunables(sys, highdimarr, [q[1:2], r[1, :], q[3], r[2, :], p]; dim = 2)
```

--------------------------------

### assertions

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Gets the assertions for a system and its subsystems.

```APIDOC
## assertions

### Description
Gets the assertions for a system `sys` and its subsystems.

### Method
Function

### Signature
```julia
assertions(sys::ModelingToolkitBase.AbstractSystem) -> Any
```
```

--------------------------------

### Generate Initialization System

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/initialization

Constructs the initialization system for a given system (e.g., a pendulum model). It takes system-level information and additional nonlinear equations. Initial conditions and guesses for parameters can be provided.

```julia
isys = generate_initializesystem(pend; op = [x => 1.0, y => 0.0], guesses = [λ => 1])
```

--------------------------------

### ModelingToolkitBase.constraints

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Gets all constraints in the system `sys` and all of its subsystems.

```APIDOC
## ModelingToolkitBase.constraints

### Description
Get all constraints in the system `sys` and all of its subsystems, appropriately namespaced.

### Method
```julia
constraints(sys::ModelingToolkitBase.AbstractSystem) -> Any
```
```

--------------------------------

### Instantiate Pyomo and InfiniteOpt Collocation Solvers

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/dynamic_opt

Instantiate Pyomo and InfiniteOpt collocation solvers. Pyomo uses a derivative method with optional collocation points, while InfiniteOpt uses a solver object and a derivative method.

```julia
PyomoCollocation("ipopt", LagrangeRadau(2))
InfiniteOptCollocation(Ipopt.Optimizer, OrthogonalCollocation(3))
```

--------------------------------

### ModelingToolkitBase.jumps

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Gets the flattened jumps of the system and all its subsystems.

```APIDOC
## ModelingToolkitBase.jumps

### Description
Get the flattened jumps of the system. In other words, obtain all of the jumps in `sys` and all the subsystems of `sys` (appropriately namespaced).

### Method
```julia
jumps(sys::ModelingToolkitBase.AbstractSystem) -> Any
```
```

--------------------------------

### Create InitializationProblem for Well-Conditioned System

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/initialization

Construct an InitializationProblem for a well-conditioned system, resulting in a NonlinearProblem. This highlights the difference in problem type when the Jacobian is square.

```julia
iprob = ModelingToolkit.InitializationProblem(pend, 0.0,
    [x => 1, D(x) => 0.0, g => 1], guesses = [λ => 1, y => 0])
```

--------------------------------

### symbolic_tstops

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Gets the time stops present in a system and its subsystems.

```APIDOC
## symbolic_tstops

### Description
Get the tstops present in `sys` and its subsystems, appropriately namespaced.

### Method
```julia
symbolic_tstops(
    sys::ModelingToolkitBase.AbstractSystem
) -> Any
```
```

--------------------------------

### Create SciMLBase.OptimizationProblem

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/problems

Builds an OptimizationProblem from a system and an operating point. Supports in-place operations and specialization. The operating point maps system variables to initial values.

```julia
SciMLBase.SciMLBase.OptimizationProblem(sys::System, op; kwargs...)
SciMLBase.SciMLBase.OptimizationProblem{iip}(sys::System, op; kwargs...)
SciMLBase.SciMLBase.OptimizationProblem{iip, specialize}(sys::System, op; kwargs...)
```

--------------------------------

### Instantiate Mass Component

Source: https://docs.sciml.ai/ModelingToolkit/stable/examples/spring_mass

Shows how to create a 'Mass' instance with a specific name. The output displays the model structure including equations, unknowns, and parameters.

```julia
Mass(name = :mass1)
```

```julia
@named mass1 = Mass()
```

--------------------------------

### Get System Name (Base)

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Obtains the name of the system.

```julia
nameof(sys::ModelingToolkitBase.AbstractSystem) -> Any
```

--------------------------------

### ModelingToolkitBase.equations

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Gets the flattened equations of the system `sys` and its subsystems.

```APIDOC
## ModelingToolkitBase.equations

### Description
Get the flattened equations of the system `sys` and its subsystems. It may include some abbreviations and aliases of observables. It is often the most useful way to inspect the equations of a system.

### Method
```julia
equations(sys::AbstractSystem)
```

### See Also
`full_equations` and `ModelingToolkitBase.get_eqs`
```

--------------------------------

### Construct and compile system

Source: https://docs.sciml.ai/ModelingToolkit/stable/examples/perturbation

Constructs a ModelingToolkit System from the perturbed equations and compiles it for numerical solving. This automatically inserts dummy derivatives for velocities.

```julia
@mtkcompile sys = System(eqs_pert, t)
```

```julia
Model sys:
Equations (6):
  6 standard: see equations(sys)
Unknowns (6): see unknowns(sys)
  x₂(t)
  x₁(t)
  x₀(t)
  x₂ˍt(t)
  ⋮
```

--------------------------------

### Inspect Equations of Initialization System

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/initialization

Retrieves and displays the equations that constitute the constructed initialization system. This helps in understanding the system's structure and constraints.

```julia
equations(isys)
```

--------------------------------

### Accessing and Modifying Bindings and Initial Conditions

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/initialization

Shows how to inspect the defined bindings and initial conditions of a system and demonstrates that bindings are immutable while initial conditions can be updated.

```julia
julia> bindings(sys)
ReadOnlyDicts.ReadOnlyDict{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymReal}, SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymReal}, ModelingToolkitBase.AtomicArrayDict{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymReal}, Dict{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymReal}, SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymReal}}}}} with 2 entries:
  q    => 2p
  y(t) => x(t)
julia> @test_throws Exception bindings(sys)[y] = 2x # throwsTest Passed
      Thrown: MethodError
julia> initial_conditions(sys)
ModelingToolkitBase.AtomicArrayDict{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymReal}, Dict{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymReal}, SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymReal}}}} with 2 entries:
  x(t) => 1
  p    => 1
julia> initial_conditions(sys)[x] = 22
julia> initial_conditions(sys)
ModelingToolkitBase.AtomicArrayDict{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymReal}, Dict{SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymReal}, SymbolicUtils.BasicSymbolicImpl.var"typeof(BasicSymbolicImpl)"{SymReal}}}} with 2 entries:
  x(t) => 2
  p    => 1
```

--------------------------------

### Get Variable-to-Variable Dependencies

Source: https://docs.sciml.ai/ModelingToolkit/stable/basics/DependencyGraphs

Calculates the direct dependencies between variables in a system.

```julia
varvardep = varvar_dependencies(asgraph(jumpsys), variable_dependencies(jumpsys))
```

--------------------------------

### Get top-level parameters

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Replicates the behaviour of `parameters`, but ignores parameters of subsystems.

```julia
parameters_toplevel(sys::AbstractSystem)
```

--------------------------------

### Generate Initialization System

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/initialization

Generates a system of nonlinear equations to solve for the initial conditions of a given system. Supports time-dependent and time-independent initialization.

```julia
generate_initializesystem(
    sys::ModelingToolkitBase.AbstractSystem;
    time_dependent_init,
    kwargs...
) -> System
```

--------------------------------

### Get top-level unknowns

Source: https://docs.sciml.ai/ModelingToolkit/stable/API/System

Replicates the behaviour of `unknowns`, but ignores unknowns of subsystems.

```julia
unknowns_toplevel(sys::AbstractSystem)
```

--------------------------------

### generate_initializesystem

Source: https://docs.sciml.ai/ModelingToolkit/stable/tutorials/initialization

Generates the initialization system for a given system. This system of nonlinear equations is used to solve for the full set of initial conditions.

```APIDOC
## Function `ModelingToolkitBase.generate_initializesystem`

### Description
Generate the initialization system for `sys`. The initialization system is a system of nonlinear equations that solve for the full set of initial conditions of `sys` given specified constraints.

### Method
```julia
generate_initializesystem(
    sys::ModelingToolkitBase.AbstractSystem;
    time_dependent_init,
    kwargs...
) -> System
```

### Parameters
#### Keyword Arguments
* `time_dependent_init` : Whether to create an initialization system for a time-dependent system. A time-dependent initialization requires a time-dependent `sys`, but a time- independent initialization can be created regardless.
* `op`: The operating point of user-specified initial conditions of variables in `sys`.
* `initialization_eqs`: Additional initialization equations to use apart from those in `initialization_equations(sys)`.
* `guesses`: Additional guesses to use apart from those in `guesses(sys)`.
* `default_dd_guess`: Default guess for dummy derivative variables in time-dependent initialization.
* `algebraic_only`: If `false`, does not use initialization equations (provided via the keyword or part of the system) to construct initialization.
* `check_defguess`: Whether to error when a variable does not have a default or guess despite ModelingToolkitBase expecting it to.
* `name`: The name of the initialization system.

All other keyword arguments are forwarded to the `System` constructor.
```

--------------------------------

### Get Variable-to-Equation Dependencies

Source: https://docs.sciml.ai/ModelingToolkit/stable/basics/DependencyGraphs

Retrieves the dependencies of variables on equations from a given system.

```julia
variable_dependencies(jumpsys)
```
Tokens:
Raw