Merge branch 'master' into id-tutorial

Author: iliailmer

.github/workflows/Downstream.yml

@@ -7,23 +7,24 @@ on:
 
 jobs:
   test:
-    name: ${{ matrix.package.repo }}/${{ matrix.package.group }}
+    name: ${{ matrix.package.repo }}/${{ matrix.package.group }}/${{ matrix.julia-version }}
     runs-on: ${{ matrix.os }}
     env:
       GROUP: ${{ matrix.package.group }}
     strategy:
       fail-fast: false
       matrix:
-        julia-version: [1]
+        julia-version: [1,1.6]
         os: [ubuntu-latest]
         package:
+          - {user: SciML, repo: SciMLBase.jl, group: Downstream}
           - {user: SciML, repo: Catalyst.jl, group: All}
           - {user: SciML, repo: CellMLToolkit.jl, group: All}
           - {user: SciML, repo: SBMLToolkit.jl, group: All}
           - {user: SciML, repo: NeuralPDE.jl, group: NNPDE}
           - {user: SciML, repo: DataDrivenDiffEq.jl, group: Standard}
           - {user: SciML, repo: StructuralIdentifiability.jl, group: All}
-          
+          - {user: SciML, repo: ModelingToolkitStandardLibrary.jl}
     steps:
       - uses: actions/checkout@v2
       - uses: julia-actions/setup-julia@v1

.github/workflows/ci.yml

@@ -9,11 +9,18 @@ on:
 jobs:
   test:
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        group:
+          - All
+        version:
+          - '1'
+          - '1.6'
     steps:
       - uses: actions/checkout@v2
       - uses: julia-actions/setup-julia@v1
         with:
-          version: 1
+          version: ${{ matrix.version }}
       - uses: actions/cache@v1
         env:
           cache-name: cache-artifacts

NEWS.md

@@ -0,0 +1,10 @@
+# ModelingToolkit v8 Release Notes
+
+
+### Upgrade guide
+
+- `connect` should not be overloaded by users anymore. `[connect = Flow]`
+  informs ModelingToolkit that particular variable in a connector ought to sum
+  to zero, and by default, variables are equal in a connection. Please check out
+  [acausal components tutorial](https://mtk.sciml.ai/dev/tutorials/acausal_components/)
+  for examples.

Project.toml

@@ -1,7 +1,7 @@
 name = "ModelingToolkit"
 uuid = "961ee093-0014-501f-94e3-6117800e7a78"
 authors = ["Chris Rackauckas <[email protected]>"]
-version = "7.0.0"
+version = "8.3.1"
 
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
@@ -45,19 +45,19 @@ Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d"
 
 [compat]
 AbstractTrees = "0.3"
-ArrayInterface = "3.1.39"
+ArrayInterface = "3.1.39, 4"
 ConstructionBase = "1"
 DataStructures = "0.17, 0.18"
-DiffEqBase = "6.54.0"
+DiffEqBase = "6.81.0"
 DiffEqCallbacks = "2.16"
-DiffEqJump = "7.0"
+DiffEqJump = "7.0, 8"
 DiffRules = "0.1, 1.0"
 Distributions = "0.23, 0.24, 0.25"
 DocStringExtensions = "0.7, 0.8"
 DomainSets = "0.5"
 Graphs = "1.4"
 IfElse = "0.1"
-JuliaFormatter = "0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18"
+JuliaFormatter = "0.12, 0.13, 0.14, 0.15, 0.16, 0.17, 0.18, 0.19, 0.20, 0.21"
 LabelledArrays = "1.3"
 Latexify = "0.11, 0.12, 0.13, 0.14, 0.15"
 MacroTools = "0.5"
@@ -70,13 +70,13 @@ RuntimeGeneratedFunctions = "0.4.3, 0.5"
 SafeTestsets = "0.0.1"
 SciMLBase = "1.3"
 Setfield = "0.7, 0.8"
-SpecialFunctions = "0.7, 0.8, 0.9, 0.10, 1.0"
+SpecialFunctions = "0.7, 0.8, 0.9, 0.10, 1.0, 2"
 StaticArrays = "0.10, 0.11, 0.12, 1.0"
-SymbolicUtils = "0.18"
+SymbolicUtils = "0.18, 0.19"
 Symbolics = "4.0.0"
 UnPack = "0.1, 1.0"
 Unitful = "1.1"
-julia = "1.2"
+julia = "1.6"
 
 [extras]
 BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf"

docs/src/basics/Composition.md

@@ -167,13 +167,17 @@ before numerically solving. The `structural_simplify` function removes
 these trivial equality relationships and trivial singularity equations,
 i.e. equations which result in `0~0` expressions, in over-specified systems.
 
-## Inheritance and Combine (TODO)
+## Inheritance and Combine
 
-Model inheritance can be done in two ways: explicitly or implicitly.
-The explicit way is to shadow variables with equality expressions.
-For example, let's assume we have three separate systems which we
-want to compose to a single one. This is how one could explicitly
-forward all states and parameters to the higher level system:
+Model inheritance can be done in two ways: implicitly or explicitly. First, one
+can use the `extend` function to extend a base model with another set of
+equations, states, and parameters. An example can be found in the
+[acausal components tutorial](@ref acausal).
+
+The explicit way is to shadow variables with equality expressions. For example,
+let's assume we have three separate systems which we want to compose to a single
+one. This is how one could explicitly forward all states and parameters to the
+higher level system:
 
 ```julia
 using ModelingToolkit, OrdinaryDiffEq, Plots
@@ -259,7 +263,7 @@ ODESystem(eqs, ...; continuous_events::Pair{Vector{Equation}, Vector{Equation}})
 ```
 where equations can be added that evaluate to 0 at discontinuities.
 
-To model events that have an affect on the state, provide `events::Pair{Vector{Equation}, Vector{Equation}}` where the first entry in the pair is a vector of equations describing event conditions, and the second vector of equations describe the affect on the state. The affect equations must be on the form
+To model events that have an effect on the state, provide `events::Pair{Vector{Equation}, Vector{Equation}}` where the first entry in the pair is a vector of equations describing event conditions, and the second vector of equations describe the effect on the state. The effect equations must be of the form
 ```
 single_state_variable ~ expression_involving_any_variables
 ```
@@ -275,7 +279,7 @@ function UnitMassWithFriction(k; name)
     D(x) ~ v
     D(v) ~ sin(t) - k*sign(v) # f = ma, sinusoidal force acting on the mass, and Coulomb friction opposing the movement
   ]
-  ODESystem(eqs, t, continuous_events=[v ~ 0], name=name) # when v = 0 there is a discontinuity
+  ODESystem(eqs, t; continuous_events=[v ~ 0], name) # when v = 0 there is a discontinuity
 end
 @named m = UnitMassWithFriction(0.7)
 prob = ODEProblem(m, Pair[], (0, 10pi))
@@ -296,7 +300,7 @@ affect   = [v ~ -v] # the effect is that the velocity changes sign
 @named ball = ODESystem([
     D(x) ~ v
     D(v) ~ -9.8
-], t, continuous_events = root_eqs => affect) # equation => affect
+], t; continuous_events = root_eqs => affect) # equation => affect
 
 ball = structural_simplify(ball)
 
@@ -323,7 +327,7 @@ continuous_events = [ # This time we have a vector of pairs
     D(y)  ~ vy,
     D(vx) ~ -9.8-0.1vx, # gravity + some small air resistance
     D(vy) ~ -0.1vy,
-], t, continuous_events = continuous_events)
+], t; continuous_events)
 
 
 ball = structural_simplify(ball)
@@ -340,4 +344,4 @@ tv = sort([LinRange(0, 10, 200); sol.t])
 plot(sol(tv)[y], sol(tv)[x], line_z=tv)
 vline!([-1.5, 1.5], l=(:black, 5), primary=false)
 hline!([0], l=(:black, 5), primary=false)
-```
+```

docs/src/mtkitize_tutorials/modelingtoolkitize.md

@@ -27,7 +27,5 @@ sys = modelingtoolkitize(prob)
 Using this, we can symbolically build the Jacobian and then rebuild the ODEProblem:
 
 ```julia
-jac = eval(ModelingToolkit.generate_jacobian(sys)[2])
-f = ODEFunction(rober, jac=jac)
-prob_jac = ODEProblem(f,[1.0,0.0,0.0],(0.0,1e5),(0.04,3e7,1e4))
+prob_jac = ODEProblem(sys,[],(0.0,1e5),jac=true)
 ```

docs/src/systems/NonlinearSystem.md

@@ -23,6 +23,7 @@ tearing
 ## Analyses
 
 ```@docs
+ModelingToolkit.isaffine
 ModelingToolkit.islinear
 ```
 

docs/src/systems/ODESystem.md

@@ -29,6 +29,7 @@ tearing
 ```@docs
 ModelingToolkit.islinear
 ModelingToolkit.isautonomous
+ModelingToolkit.isaffine
 ```
 
 ## Applicable Calculation and Generation Functions

docs/src/tutorials/acausal_components.md

@@ -16,22 +16,10 @@ using ModelingToolkit, Plots, DifferentialEquations
 
 @variables t
 @connector function Pin(;name)
-    sts = @variables v(t)=1.0 i(t)=1.0
+    sts = @variables v(t)=1.0 i(t)=1.0 [connect = Flow]
     ODESystem(Equation[], t, sts, []; name=name)
 end
 
-function ModelingToolkit.connect(::Type{Pin}, ps...)
-    eqs = [
-           0 ~ sum(p->p.i, ps) # KCL
-          ]
-    # KVL
-    for i in 1:length(ps)-1
-        push!(eqs, ps[i].v ~ ps[i+1].v)
-    end
-
-    return eqs
-end
-
 function Ground(;name)
     @named g = Pin()
     eqs = [g.v ~ 0]
@@ -92,7 +80,8 @@ V = 1.0
 rc_eqs = [
           connect(source.p, resistor.p)
           connect(resistor.n, capacitor.p)
-          connect(capacitor.n, source.n, ground.g)
+          connect(capacitor.n, source.n)
+          connect(capacitor.n, ground.g)
          ]
 
 @named _rc_model = ODESystem(rc_eqs, t)
@@ -117,11 +106,15 @@ For each of our components we use a Julia function which emits an `ODESystem`.
 At the top we start with defining the fundamental qualities of an electrical
 circuit component. At every input and output pin a circuit component has
 two values: the current at the pin and the voltage. Thus we define the `Pin`
-component (connector) to simply be the values there:
+component (connector) to simply be the values there. Whenever two `Pin`s in a
+circuit are connected together, the system satisfies [Kirchoff's laws](https: //en.wikipedia.org/wiki/Kirchhoff%27s_circuit_laws),
+i.e. that currents sum to zero and voltages across the pins are equal.
+`[connect = Flow]` informs MTK that currents ought to sum to zero, and by
+default, variables are equal in a connection.
 
 ```julia
 @connector function Pin(;name)
-    sts = @variables v(t)=1.0 i(t)=1.0
+    sts = @variables v(t)=1.0 i(t)=1.0 [connect = Flow]
     ODESystem(Equation[], t, sts, []; name=name)
 end
 ```
@@ -253,26 +246,6 @@ V = 1.0
 @named ground = Ground()
 ```
 
-Next we have to define how we connect the circuit. Whenever two `Pin`s in a
-circuit are connected together, the system satisfies
-[Kirchoff's laws](https://en.wikipedia.org/wiki/Kirchhoff%27s_circuit_laws),
-i.e. that currents sum to zero and voltages across the pins are equal. Thus
-we will build a helper function `connect_pins` which implements these rules:
-
-```julia
-function ModelingToolkit.connect(::Type{Pin}, ps...)
-    eqs = [
-           0 ~ sum(p->p.i, ps) # KCL
-          ]
-    # KVL
-    for i in 1:length(ps)-1
-        push!(eqs, ps[i].v ~ ps[i+1].v)
-    end
-
-    return eqs
-end
-```
-
 Finally we will connect the pieces of our circuit together. Let's connect the
 positive pin of the resistor to the source, the negative pin of the resistor
 to the capacitor, and the negative pin of the capacitor to a junction between
@@ -282,7 +255,8 @@ the source and the ground. This would mean our connection equations are:
 rc_eqs = [
           connect(source.p, resistor.p)
           connect(resistor.n, capacitor.p)
-          connect(capacitor.n, source.n, ground.g)
+          connect(capacitor.n, source.n)
+          connect(capacitor.n, ground.g)
          ]
 ```
 

docs/src/tutorials/spring_mass.md

@@ -6,14 +6,15 @@ In this tutorial we will build a simple component-based model of a spring-mass s
 
 ```julia
 using ModelingToolkit, Plots, DifferentialEquations, LinearAlgebra
+using Symbolics: scalarize
 
 @variables t
 D = Differential(t)
 
 function Mass(; name, m = 1.0, xy = [0., 0.], u = [0., 0.])
     ps = @parameters m=m
     sts = @variables pos[1:2](t)=xy v[1:2](t)=u
-    eqs = collect(D.(pos) .~ v)
+    eqs = scalarize(D.(pos) .~ v)
     ODESystem(eqs, t, [pos..., v...], ps; name)
 end
 
@@ -25,12 +26,12 @@ end
 
 function connect_spring(spring, a, b)
     [
-        spring.x ~ norm(collect(a .- b))
-        collect(spring.dir .~ collect(a .- b))
+        spring.x ~ norm(scalarize(a .- b))
+        scalarize(spring.dir .~ scalarize(a .- b))
     ]
 end
 
-spring_force(spring) = -spring.k .* collect(spring.dir) .* (spring.x - spring.l)  ./ spring.x
+spring_force(spring) = -spring.k .* scalarize(spring.dir) .* (spring.x - spring.l)  ./ spring.x
 
 m = 1.0
 xy = [1., -1.]
@@ -43,7 +44,7 @@ g = [0., -9.81]
 
 eqs = [
     connect_spring(spring, mass.pos, center)
-    collect(D.(mass.v) .~ spring_force(spring) / mass.m .+ g)
+    scalarize(D.(mass.v) .~ spring_force(spring) / mass.m .+ g)
 ]
 
 @named _model = ODESystem(eqs, t)
@@ -65,7 +66,7 @@ For each component we use a Julia function that returns an `ODESystem`. At the t
 function Mass(; name, m = 1.0, xy = [0., 0.], u = [0., 0.])
     ps = @parameters m=m
     sts = @variables pos[1:2](t)=xy v[1:2](t)=u
-    eqs = collect(D.(pos) .~ v)
+    eqs = scalarize(D.(pos) .~ v)
     ODESystem(eqs, t, [pos..., v...], ps; name)
 end
 ```
@@ -97,16 +98,16 @@ We now define functions that help construct the equations for a mass-spring syst
 ```julia
 function connect_spring(spring, a, b)
     [
-        spring.x ~ norm(collect(a .- b))
-        collect(spring.dir .~ collect(a .- b))
+        spring.x ~ norm(scalarize(a .- b))
+        scalarize(spring.dir .~ scalarize(a .- b))
     ]
 end
 ```
 
 Lastly, we define the `spring_force` function that takes a `spring` and returns the force exerted by this spring.
 
 ```julia
-spring_force(spring) = -spring.k .* collect(spring.dir) .* (spring.x - spring.l)  ./ spring.x
+spring_force(spring) = -spring.k .* scalarize(spring.dir) .* (spring.x - spring.l)  ./ spring.x
 ```
 
 To create our system, we will first create the components: a mass and a spring. This is done as follows:
@@ -127,7 +128,7 @@ We can now create the equations describing this system, by connecting `spring` t
 ```julia
 eqs = [
     connect_spring(spring, mass.pos, center)
-    collect(D.(mass.v) .~ spring_force(spring) / mass.m .+ g)
+    scalarize(D.(mass.v) .~ spring_force(spring) / mass.m .+ g)
 ]
 ```
 
@@ -230,4 +231,4 @@ We can also plot the path of the mass:
 plot(sol, vars = (mass.pos[1], mass.pos[2]))
 ```
 
-![plotpos](https://user-images.githubusercontent.com/23384717/130322197-cff35eb7-0739-471d-a3d9-af83d87f1cc7.png)
+![plotpos](https://user-images.githubusercontent.com/23384717/130322197-cff35eb7-0739-471d-a3d9-af83d87f1cc7.png)