docs: rename ODESystem to System

Author: AayushSabharwal

docs/src/API/variables.md

@@ -34,7 +34,7 @@ When variables with descriptions are present in systems, they will be printed wh
 ```@example metadata
 @variables u(t) [description = "A short description of u"]
 @parameters p [description = "A description of p"]
-@named sys = ODESystem([u ~ p], t)
+@named sys = System([u ~ p], t)
 show(stdout, "text/plain", sys) # hide
 ```
 
@@ -298,7 +298,7 @@ In the example below, we define a system with tunable parameters and extract bou
 @parameters k [tunable = true, bounds = (0, Inf)]
 eqs = [D(x) ~ (-x + k * u) / T # A first-order system with time constant T and gain k
        y ~ x]
-sys = ODESystem(eqs, t, name = :tunable_first_order)
+sys = System(eqs, t, name = :tunable_first_order)
 ```
 
 ```@example metadata

docs/src/basics/AbstractSystem.md

@@ -12,7 +12,7 @@ model manipulation and compilation.
 There are three immediate subtypes of `AbstractSystem`, classified by how many independent variables each type has:
 
   - `AbstractTimeIndependentSystem`: has no independent variable (e.g.: `NonlinearSystem`)
-  - `AbstractTimeDependentSystem`: has a single independent variable (e.g.: `ODESystem`)
+  - `AbstractTimeDependentSystem`: has a single independent variable (e.g.: `System`)
   - `AbstractMultivariateSystem`: may have multiple independent variables (e.g.: `PDESystem`)
 
 ## Constructors and Naming

docs/src/basics/Composition.md

@@ -21,7 +21,7 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 function decay(; name)
     @parameters a
     @variables x(t) f(t)
-    ODESystem([
+    System([
             D(x) ~ -a * x + f
         ], t;
         name = name)
@@ -31,7 +31,7 @@ end
 @named decay2 = decay()
 
 connected = compose(
-    ODESystem([decay2.f ~ decay1.x
+    System([decay2.f ~ decay1.x
                D(decay1.f) ~ 0], t; name = :connected), decay1, decay2)
 
 equations(connected)
@@ -69,7 +69,7 @@ subsystems. A model is the composition of itself and its subsystems.
 For example, if we have:
 
 ```julia
-@named sys = compose(ODESystem(eqs, indepvar, unknowns, ps), subsys)
+@named sys = compose(System(eqs, indepvar, unknowns, ps), subsys)
 ```
 
 the `equations` of `sys` is the concatenation of `get_eqs(sys)` and
@@ -122,7 +122,7 @@ With symbolic parameters, it is possible to set the default value of a parameter
 
 ```julia
 # ...
-sys = ODESystem(
+sys = System(
 # ...
 # directly in the defaults argument
     defaults = Pair{Num, Any}[x => u,
@@ -144,20 +144,20 @@ d = GlobalScope(d)
 
 p = [a, b, c, d]
 
-level0 = ODESystem(Equation[], t, [], p; name = :level0)
-level1 = ODESystem(Equation[], t, [], []; name = :level1) ∘ level0
+level0 = System(Equation[], t, [], p; name = :level0)
+level1 = System(Equation[], t, [], []; name = :level1) ∘ level0
 parameters(level1)
 #level0₊a
 #b
 #c
 #d
-level2 = ODESystem(Equation[], t, [], []; name = :level2) ∘ level1
+level2 = System(Equation[], t, [], []; name = :level2) ∘ level1
 parameters(level2)
 #level1₊level0₊a
 #level1₊b
 #c
 #d
-level3 = ODESystem(Equation[], t, [], []; name = :level3) ∘ level2
+level3 = System(Equation[], t, [], []; name = :level3) ∘ level2
 parameters(level3)
 #level2₊level1₊level0₊a
 #level2₊level1₊b
@@ -194,12 +194,12 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 N = S + I + R
 @parameters β, γ
 
-@named seqn = ODESystem([D(S) ~ -β * S * I / N], t)
-@named ieqn = ODESystem([D(I) ~ β * S * I / N - γ * I], t)
-@named reqn = ODESystem([D(R) ~ γ * I], t)
+@named seqn = System([D(S) ~ -β * S * I / N], t)
+@named ieqn = System([D(I) ~ β * S * I / N - γ * I], t)
+@named reqn = System([D(R) ~ γ * I], t)
 
 sir = compose(
-    ODESystem(
+    System(
         [
             S ~ ieqn.S,
             I ~ seqn.I,
@@ -266,6 +266,6 @@ equations are discontinuous in either the unknown or one of its derivatives. Thi
 causes the solver to take very small steps around the discontinuity, and
 sometimes leads to early stopping due to `dt <= dt_min`. The correct way to
 handle such dynamics is to tell the solver about the discontinuity by a
-root-finding equation, which can be modeling using [`ODESystem`](@ref)'s event
+root-finding equation, which can be modeling using [`System`](@ref)'s event
 support. Please see the tutorial on [Callbacks and Events](@ref events) for
 details and examples.

docs/src/basics/Debugging.md

@@ -12,7 +12,7 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 @variables u1(t) u2(t) u3(t)
 eqs = [D(u1) ~ -√(u1), D(u2) ~ -√(u2), D(u3) ~ -√(u3)]
 defaults = [u1 => 1.0, u2 => 2.0, u3 => 3.0]
-@named sys = ODESystem(eqs, t; defaults)
+@named sys = System(eqs, t; defaults)
 sys = mtkcompile(sys)
 ```
 
@@ -38,7 +38,7 @@ We could have figured that out ourselves, but it is not always so obvious for mo
 Suppose we also want to validate that `u1 + u2 >= 2.0`. We can do this via the assertions functionality.
 
 ```@example debug
-@mtkcompile sys = ODESystem(eqs, t; defaults, assertions = [(u1 + u2 >= 2.0) => "Oh no!"])
+@mtkcompile sys = System(eqs, t; defaults, assertions = [(u1 + u2 >= 2.0) => "Oh no!"])
 ```
 
 The assertions must be an iterable of pairs, where the first element is the symbolic condition and

docs/src/basics/Events.md

@@ -9,7 +9,7 @@ or into more specialized callback types from the
 [DiffEqCallbacks.jl](https://docs.sciml.ai/DiffEqDocs/stable/features/callback_library/)
 library.
 
-[`ODESystem`](@ref)s and [`SDESystem`](@ref)s accept keyword arguments
+[`System`](@ref)s and [`SDESystem`](@ref)s accept keyword arguments
 `continuous_events` and `discrete_events` to symbolically encode continuous or
 discrete callbacks. [`JumpSystem`](@ref)s currently support only
 `discrete_events`. Continuous events are applied when a given condition becomes
@@ -59,7 +59,7 @@ For example, consider the following system.
 ```julia
 @variables x(t) y(t)
 @parameters p(t)
-@mtkcompile sys = ODESystem([x * y ~ p, D(x) ~ 0], t)
+@mtkcompile sys = System([x * y ~ p, D(x) ~ 0], t)
 event = [t == 1] => [x ~ Pre(x) + 1]
 ```
 
@@ -132,7 +132,7 @@ function UnitMassWithFriction(k; name)
     @variables x(t)=0 v(t)=0
     eqs = [D(x) ~ v
            D(v) ~ sin(t) - k * sign(v)]
-    ODESystem(eqs, t; continuous_events = [v ~ 0], name) # when v = 0 there is a discontinuity
+    System(eqs, t; continuous_events = [v ~ 0], name) # when v = 0 there is a discontinuity
 end
 @mtkcompile m = UnitMassWithFriction(0.7)
 prob = ODEProblem(m, Pair[], (0, 10pi))
@@ -154,7 +154,7 @@ like this
 root_eqs = [x ~ 0]  # the event happens at the ground x(t) = 0
 affect = [v ~ -Pre(v)] # the effect is that the velocity changes sign
 
-@mtkcompile ball = ODESystem(
+@mtkcompile ball = System(
     [D(x) ~ v
      D(v) ~ -9.8], t; continuous_events = root_eqs => affect) # equation => affect
 
@@ -175,7 +175,7 @@ Multiple events? No problem! This example models a bouncing ball in 2D that is e
 continuous_events = [[x ~ 0] => [vx ~ -Pre(vx)]
                      [y ~ -1.5, y ~ 1.5] => [vy ~ -Pre(vy)]]
 
-@mtkcompile ball = ODESystem(
+@mtkcompile ball = System(
     [
         D(x) ~ vx,
         D(y) ~ vy,
@@ -255,7 +255,7 @@ end
 
 reflect = [x ~ 0] => (bb_affect!, [v], [], [], nothing)
 
-@mtkcompile bb_sys = ODESystem(bb_eqs, t, sts, par,
+@mtkcompile bb_sys = System(bb_eqs, t, sts, par,
     continuous_events = reflect)
 
 u0 = [v => 0.0, x => 1.0]
@@ -300,7 +300,7 @@ injection = (t == tinject) => [N ~ Pre(N) + M]
 u0 = [N => 0.0]
 tspan = (0.0, 20.0)
 p = [α => 100.0, tinject => 10.0, M => 50]
-@mtkcompile osys = ODESystem(eqs, t, [N], [α, M, tinject]; discrete_events = injection)
+@mtkcompile osys = System(eqs, t, [N], [α, M, tinject]; discrete_events = injection)
 oprob = ODEProblem(osys, u0, tspan, p)
 sol = solve(oprob, Tsit5(); tstops = 10.0)
 plot(sol)
@@ -319,7 +319,7 @@ to
 ```@example events
 injection = ((t == tinject) & (N < 50)) => [N ~ Pre(N) + M]
 
-@mtkcompile osys = ODESystem(eqs, t, [N], [M, tinject, α]; discrete_events = injection)
+@mtkcompile osys = System(eqs, t, [N], [M, tinject, α]; discrete_events = injection)
 oprob = ODEProblem(osys, u0, tspan, p)
 sol = solve(oprob, Tsit5(); tstops = 10.0)
 plot(sol)
@@ -346,7 +346,7 @@ killing = ModelingToolkit.SymbolicDiscreteCallback(
 
 tspan = (0.0, 30.0)
 p = [α => 100.0, tinject => 10.0, M => 50, tkill => 20.0]
-@mtkcompile osys = ODESystem(eqs, t, [N], [α, M, tinject, tkill];
+@mtkcompile osys = System(eqs, t, [N], [α, M, tinject, tkill];
     discrete_events = [injection, killing])
 oprob = ODEProblem(osys, u0, tspan, p)
 sol = solve(oprob, Tsit5(); tstops = [10.0, 20.0])
@@ -375,7 +375,7 @@ killing = ModelingToolkit.SymbolicDiscreteCallback(
     [20.0] => [α ~ 0.0], discrete_parameters = α, iv = t)
 
 p = [α => 100.0, M => 50]
-@mtkcompile osys = ODESystem(eqs, t, [N], [α, M];
+@mtkcompile osys = System(eqs, t, [N], [α, M];
     discrete_events = [injection, killing])
 oprob = ODEProblem(osys, u0, tspan, p)
 sol = solve(oprob, Tsit5())
@@ -415,7 +415,7 @@ example:
 
 ev = ModelingToolkit.SymbolicDiscreteCallback(
     1.0 => [c ~ Pre(c) + 1], discrete_parameters = c, iv = t)
-@mtkcompile sys = ODESystem(
+@mtkcompile sys = System(
     D(x) ~ c * cos(x), t, [x], [c]; discrete_events = [ev])
 
 prob = ODEProblem(sys, [x => 0.0], (0.0, 2pi), [c => 1.0])
@@ -436,7 +436,7 @@ will be saved. If we repeat the above example with `c` not a `discrete_parameter
 @variables x(t)
 @parameters c(t)
 
-@mtkcompile sys = ODESystem(
+@mtkcompile sys = System(
     D(x) ~ c * cos(x), t, [x], [c]; discrete_events = [1.0 => [c ~ Pre(c) + 1]])
 
 prob = ODEProblem(sys, [x => 0.0], (0.0, 2pi), [c => 1.0])
@@ -537,7 +537,7 @@ will write `furnace_on = false` back to the system, and when `temp = furnace_on_
 to the system.
 
 ```@example events
-@named sys = ODESystem(
+@named sys = System(
     eqs, t, [temp], params; continuous_events = [furnace_disable, furnace_enable])
 ss = mtkcompile(sys)
 prob = ODEProblem(ss, [temp => 0.0, furnace_on => true], (0.0, 10.0))
@@ -650,7 +650,7 @@ affect activation point, with -1 mapped to 0.
 We can now simulate the encoder.
 
 ```@example events
-@named sys = ODESystem(
+@named sys = System(
     eqs, t, [theta, omega], params; continuous_events = [qAevt, qBevt])
 ss = mtkcompile(sys)
 prob = ODEProblem(ss, [theta => 0.0], (0.0, pi))

docs/src/basics/FAQ.md

@@ -205,7 +205,7 @@ eqs = [x1 + x2 + 1 ~ 0
        x1 + x2 + x3 + 2 ~ 0
        x1 + D(x3) + x4 + 3 ~ 0
        2 * D(D(x1)) + D(D(x2)) + D(D(x3)) + D(x4) + 4 ~ 0]
-@named sys = ODESystem(eqs, t)
+@named sys = System(eqs, t)
 sys = mtkcompile(sys)
 prob = ODEProblem(sys, [], (0, 1))
 ```
@@ -237,7 +237,7 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 
 sts = @variables x1(t) = 0.0
 eqs = [D(x1) ~ 1.1 * x1]
-@mtkcompile sys = ODESystem(eqs, t)
+@mtkcompile sys = System(eqs, t)
 prob = ODEProblem{false}(sys, [], (0, 1); u0_constructor = x -> SVector(x...))
 ```
 
@@ -252,7 +252,7 @@ using ModelingToolkit
 @independent_variables x
 D = Differential(x)
 @variables y(x)
-@named sys = ODESystem([D(y) ~ x], x)
+@named sys = System([D(y) ~ x], x)
 ```
 
 ## Ordering of tunable parameters
@@ -279,7 +279,7 @@ using ModelingToolkit
 
 @parameters p q[1:3] r[1:2, 1:2]
 
-@named sys = ODESystem(Equation[], ModelingToolkit.t_nounits, [], [p, q, r])
+@named sys = System(Equation[], ModelingToolkit.t_nounits, [], [p, q, r])
 sys = complete(sys)
 ```
 

docs/src/basics/InputOutput.md

@@ -44,7 +44,7 @@ import ModelingToolkit: t_nounits as t, D_nounits as D
 eqs = [D(x) ~ -k * (x + u)
        y ~ x]
 
-@named sys = ODESystem(eqs, t)
+@named sys = System(eqs, t)
 f, x_sym, ps = ModelingToolkit.generate_control_function(sys, [u], simplify = true);
 nothing # hide
 ```

docs/src/basics/Linearization.md

@@ -29,12 +29,12 @@ eqs = [u ~ kp * (r - y) # P controller
        D(x) ~ -x + u    # First-order plant
        y ~ x]           # Output equation
 
-@named sys = ODESystem(eqs, t) # Do not call @mtkcompile when linearizing
+@named sys = System(eqs, t) # Do not call @mtkcompile when linearizing
 matrices, simplified_sys = linearize(sys, [r], [y]) # Linearize from r to y
 matrices
 ```
 
-The named tuple `matrices` contains the matrices of the linear statespace representation, while `simplified_sys` is an `ODESystem` that, among other things, indicates the unknown variable order in the linear system through
+The named tuple `matrices` contains the matrices of the linear statespace representation, while `simplified_sys` is an `System` that, among other things, indicates the unknown variable order in the linear system through
 
 ```@example LINEARIZE
 using ModelingToolkit: inputs, outputs
@@ -78,7 +78,7 @@ eqs = [D(x) ~ v
        D(v) ~ -k * x - k3 * x^3 - c * v + 10u.u
        y.u ~ x]
 
-@named duffing = ODESystem(eqs, t, systems = [y, u], defaults = [u.u => 0])
+@named duffing = System(eqs, t, systems = [y, u], defaults = [u.u => 0])
 
 # pass a constant value for `x`, since it is the variable we will change in operating points
 linfun, simplified_sys = linearization_function(duffing, [u.u], [y.u]; op = Dict(x => NaN));

docs/src/basics/MTKLanguage.md

@@ -16,7 +16,7 @@ equations.
 ### [Defining components with `@mtkmodel`](@id mtkmodel)
 
 `@mtkmodel` is a convenience macro to define components. It returns
-`ModelingToolkit.Model`, which includes a system constructor (`ODESystem` by
+`ModelingToolkit.Model`, which includes a system constructor (`System` by
 default), a `structure` dictionary with metadata, and flag `isconnector` which is
 set to `false`.
 
@@ -263,7 +263,7 @@ end
 
 ### Setting the type of system:
 
-By default `@mtkmodel` returns an ODESystem. Different types of system can be
+By default `@mtkmodel` returns an System. Different types of system can be
 defined with the following syntax:
 
 ```
@@ -273,20 +273,6 @@ end
 
 ```
 
-Example:
-
-```@example mtkmodel-example
-@mtkmodel Float2Bool::DiscreteSystem begin
-    @variables begin
-        u(t)::Float64
-        y(t)::Bool
-    end
-    @equations begin
-        y ~ u != 0
-    end
-end
-```
-
 ## Connectors
 
 Connectors are special models that can be used to connect different components together.
@@ -301,7 +287,7 @@ MTK provides 3 distinct connectors:
 ### [Defining connectors with `@connector`](@id connector)
 
 `@connector` returns `ModelingToolkit.Model`. It includes a constructor that returns
-a connector system (`ODESystem` by default), a `structure` dictionary with metadata, and flag `isconnector`
+a connector system (`System` by default), a `structure` dictionary with metadata, and flag `isconnector`
 which is set to `true`.
 
 A simple connector can be defined with syntax similar to following example:

docs/src/basics/Precompilation.md

@@ -21,7 +21,7 @@ module PrecompilationMWE
 using ModelingToolkit
 
 @variables x(ModelingToolkit.t_nounits)
-@named sys = ODESystem([ModelingToolkit.D_nounits(x) ~ -x + 1], 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__)
 

docs/src/basics/Validation.md

@@ -110,7 +110,7 @@ end
 sts = @variables a(t)=0 [unit = u"cm"]
 ps = @parameters s=-1 [unit = u"cm"] c=c [unit = u"cm"]
 eqs = [D(a) ~ dummycomplex(c, s);]
-sys = ODESystem(
+sys = System(
     eqs, t, [sts...;], [ps...;], name = :sys, checks = ~ModelingToolkit.CheckUnits)
 sys_simple = mtkcompile(sys)
 ```