Merge branch 'master' into myb/differential_alias

Author: YingboMa

Project.toml

@@ -1,7 +1,7 @@
 name = "ModelingToolkit"
 uuid = "961ee093-0014-501f-94e3-6117800e7a78"
 authors = ["Chris Rackauckas <[email protected]>"]
-version = "8.14.1"
+version = "8.15.1"
 
 [deps]
 AbstractTrees = "1520ce14-60c1-5f80-bbc7-55ef81b5835c"
@@ -11,7 +11,6 @@ ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9"
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"
 DiffEqBase = "2b5f629d-d688-5b77-993f-72d75c75574e"
 DiffEqCallbacks = "459566f4-90b8-5000-8ac3-15dfb0a30def"
-DiffEqJump = "c894b116-72e5-5b58-be3c-e6d8d4ac2b12"
 DiffRules = "b552c78f-8df3-52c6-915a-8e097449b14b"
 Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b"
 Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
@@ -21,6 +20,7 @@ Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
 IfElse = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 JuliaFormatter = "98e50ef6-434e-11e9-1051-2b60c6c9e899"
+JumpProcesses = "ccbc3e58-028d-4f4c-8cd5-9ae44345cda5"
 LabelledArrays = "2ee39098-c373-598a-b85f-a56591580800"
 Latexify = "23fbe1c1-3f47-55db-b15f-69d7ec21a316"
 Libdl = "8f399da3-3557-5675-b5ff-fb832c97cbdb"
@@ -30,7 +30,6 @@ NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3"
 NonlinearSolve = "8913a72c-1f9b-4ce2-8d82-65094dcecaec"
 RecursiveArrayTools = "731186ca-8d62-57ce-b412-fbd966d074cd"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
-Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 RuntimeGeneratedFunctions = "7e49a35a-f44a-4d26-94aa-eba1b4ca6b47"
 SciMLBase = "0bca4576-84f4-4d90-8ffe-ffa030f20462"
 Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
@@ -51,22 +50,21 @@ ConstructionBase = "1"
 DataStructures = "0.17, 0.18"
 DiffEqBase = "6.83.0"
 DiffEqCallbacks = "2.16"
-DiffEqJump = "7.0, 8"
 DiffRules = "0.1, 1.0"
 Distributions = "0.23, 0.24, 0.25"
 DocStringExtensions = "0.7, 0.8, 0.9"
 DomainSets = "0.5"
 Graphs = "1.5.2"
 IfElse = "0.1"
 JuliaFormatter = "1"
+JumpProcesses = "9"
 LabelledArrays = "1.3"
 Latexify = "0.11, 0.12, 0.13, 0.14, 0.15"
 MacroTools = "0.5"
 NaNMath = "0.3, 1"
 NonlinearSolve = "0.3.8"
 RecursiveArrayTools = "2.3"
 Reexport = "0.2, 1"
-Requires = "1.0"
 RuntimeGeneratedFunctions = "0.4.3, 0.5"
 SciMLBase = "1.26.2"
 Setfield = "0.7, 0.8, 1"

docs/pages.jl

@@ -8,7 +8,6 @@ pages = [
                                          "tutorials/nonlinear.md",
                                          "tutorials/optimization.md",
                                          "tutorials/stochastic_diffeq.md",
-                                         "tutorials/nonlinear_optimal_control.md",
                                          "tutorials/parameter_identifiability.md"],
     "ModelingToolkitize Tutorials" => Any["mtkitize_tutorials/modelingtoolkitize.md",
                                           "mtkitize_tutorials/modelingtoolkitize_index_reduction.md",
@@ -25,7 +24,6 @@ pages = [
                           "systems/JumpSystem.md",
                           "systems/NonlinearSystem.md",
                           "systems/OptimizationSystem.md",
-                          "systems/ControlSystem.md",
                           "systems/PDESystem.md"],
     "comparison.md",
     "internals.md",

docs/src/systems/ControlSystem.md

@@ -12,7 +12,7 @@ using Latexify, Unitful, ArrayInterfaceCore
 using MacroTools
 @reexport using UnPack
 using Setfield, ConstructionBase
-using DiffEqJump
+using JumpProcesses
 using DataStructures
 using SpecialFunctions, NaNMath
 using RuntimeGeneratedFunctions
@@ -60,8 +60,6 @@ import DiffEqBase: @add_kwonly
 
 import Graphs: SimpleDiGraph, add_edge!, incidence_matrix
 
-using Requires
-
 for fun in [:toexpr]
     @eval begin
         function $fun(eq::Equation; kw...)
@@ -121,6 +119,7 @@ include("domains.jl")
 
 include("systems/abstractsystem.jl")
 include("systems/connectors.jl")
+include("systems/callbacks.jl")
 
 include("systems/diffeqs/odesystem.jl")
 include("systems/diffeqs/sdesystem.jl")
@@ -136,8 +135,6 @@ include("systems/nonlinear/modelingtoolkitize.jl")
 
 include("systems/optimization/optimizationsystem.jl")
 
-include("systems/control/controlsystem.jl")
-
 include("systems/pde/pdesystem.jl")
 
 include("systems/sparsematrixclil.jl")
@@ -172,13 +169,11 @@ export AutoModelingToolkit
 export SteadyStateProblem, SteadyStateProblemExpr
 export JumpProblem, DiscreteProblem
 export NonlinearSystem, OptimizationSystem
-export ControlSystem
 export alias_elimination, flatten
 export connect, @connector, Connection, Flow, Stream, instream
 export isinput, isoutput, getbounds, hasbounds, isdisturbance, istunable, getdist, hasdist,
        tunable_parameters, isirreducible
 export ode_order_lowering, dae_order_lowering, liouville_transform
-export runge_kutta_discretize
 export PDESystem
 export Differential, expand_derivatives, @derivatives
 export Equation, ConstrainedEquation

docs/src/tutorials/nonlinear_optimal_control.md

@@ -52,42 +52,13 @@ function tear_graph_modia(structure::SystemStructure, ::Type{U} = Unassigned;
     var_eq_matching = complete(maximal_matching(graph, eqfilter, varfilter, U))
     var_sccs::Vector{Union{Vector{Int}, Int}} = find_var_sccs(graph, var_eq_matching)
 
-    # Here, we're using a maximal matching on the post-pantelides system to find
-    # the strongly connected components of the system (of variables that depend
-    # on each other). The strongly connected components are unique, however, the
-    # maximal matching itself is not. Every maximal matching gives rise to the
-    # same set of strongly connected components, but the associated equations need
-    # not be the same. In the absence of solvability constraints, this may be a
-    # small issue, but here it is possible that an equation got assigned to an
-    # scc that cannot actually use it for solving a variable, but still precludes
-    # another scc from using it. To avoid this, we delete any assignments that
-    # are not in the solvable graph and extend the set of considered eqauations
-    # below.
-    for var in ndsts(solvable_graph)
-        var_eq_matching[var] === unassigned && continue
-        if !(BipartiteEdge(var, var_eq_matching[var]) in solvable_graph)
-            var_eq_matching[var] = unassigned
-        end
-    end
-
     for vars in var_sccs
         filtered_vars = filter(varfilter, vars)
         ieqs = Int[var_eq_matching[v]
                    for v in filtered_vars if var_eq_matching[v] !== unassigned]
         for var in vars
             var_eq_matching[var] = unassigned
         end
-        for var in filtered_vars
-            # Add any equations that we may not have been able to use earlier to see
-            # if a different matching may have been possible.
-            for eq′ in 𝑑neighbors(solvable_graph, var)
-                eqfilter(eq′) || continue
-                eq′ in ieqs && continue
-                if invview(var_eq_matching)[eq′] === unassigned
-                    push!(ieqs, eq′)
-                end
-            end
-        end
         tear_graph_block_modia!(var_eq_matching, graph, solvable_graph, ieqs, filtered_vars)
     end
 

src/ModelingToolkit.jl

@@ -162,61 +162,6 @@ independent_variables(sys::AbstractTimeDependentSystem) = [getfield(sys, :iv)]
 independent_variables(sys::AbstractTimeIndependentSystem) = []
 independent_variables(sys::AbstractMultivariateSystem) = getfield(sys, :ivs)
 
-const NULL_AFFECT = Equation[]
-struct SymbolicContinuousCallback
-    eqs::Vector{Equation}
-    affect::Vector{Equation}
-    function SymbolicContinuousCallback(eqs::Vector{Equation}, affect = NULL_AFFECT)
-        new(eqs, affect)
-    end # Default affect to nothing
-end
-
-function Base.:(==)(e1::SymbolicContinuousCallback, e2::SymbolicContinuousCallback)
-    isequal(e1.eqs, e2.eqs) && isequal(e1.affect, e2.affect)
-end
-Base.isempty(cb::SymbolicContinuousCallback) = isempty(cb.eqs)
-function Base.hash(cb::SymbolicContinuousCallback, s::UInt)
-    s = foldr(hash, cb.eqs, init = s)
-    foldr(hash, cb.affect, init = s)
-end
-
-to_equation_vector(eq::Equation) = [eq]
-to_equation_vector(eqs::Vector{Equation}) = eqs
-function to_equation_vector(eqs::Vector{Any})
-    isempty(eqs) || error("This should never happen")
-    Equation[]
-end
-
-function SymbolicContinuousCallback(args...)
-    SymbolicContinuousCallback(to_equation_vector.(args)...)
-end # wrap eq in vector
-SymbolicContinuousCallback(p::Pair) = SymbolicContinuousCallback(p[1], p[2])
-SymbolicContinuousCallback(cb::SymbolicContinuousCallback) = cb # passthrough
-
-SymbolicContinuousCallbacks(cb::SymbolicContinuousCallback) = [cb]
-SymbolicContinuousCallbacks(cbs::Vector{<:SymbolicContinuousCallback}) = cbs
-SymbolicContinuousCallbacks(cbs::Vector) = SymbolicContinuousCallback.(cbs)
-function SymbolicContinuousCallbacks(ve::Vector{Equation})
-    SymbolicContinuousCallbacks(SymbolicContinuousCallback(ve))
-end
-function SymbolicContinuousCallbacks(others)
-    SymbolicContinuousCallbacks(SymbolicContinuousCallback(others))
-end
-SymbolicContinuousCallbacks(::Nothing) = SymbolicContinuousCallbacks(Equation[])
-
-equations(cb::SymbolicContinuousCallback) = cb.eqs
-function equations(cbs::Vector{<:SymbolicContinuousCallback})
-    reduce(vcat, [equations(cb) for cb in cbs])
-end
-affect_equations(cb::SymbolicContinuousCallback) = cb.affect
-function affect_equations(cbs::Vector{SymbolicContinuousCallback})
-    reduce(vcat, [affect_equations(cb) for cb in cbs])
-end
-namespace_equation(cb::SymbolicContinuousCallback, s)::SymbolicContinuousCallback = SymbolicContinuousCallback(namespace_equation.(equations(cb),
-                                                                                                                                   (s,)),
-                                                                                                               namespace_equation.(affect_equations(cb),
-                                                                                                                                   (s,)))
-
 for prop in [:eqs
              :noiseeqs
              :iv
@@ -507,18 +452,6 @@ function observed(sys::AbstractSystem)
             init = Equation[])]
 end
 
-function continuous_events(sys::AbstractSystem)
-    obs = get_continuous_events(sys)
-    filter(!isempty, obs)
-    systems = get_systems(sys)
-    cbs = [obs;
-           reduce(vcat,
-                  (map(o -> namespace_equation(o, s), continuous_events(s))
-                   for s in systems),
-                  init = SymbolicContinuousCallback[])]
-    filter(!isempty, cbs)
-end
-
 Base.@deprecate default_u0(x) defaults(x) false
 Base.@deprecate default_p(x) defaults(x) false
 function defaults(sys::AbstractSystem)
@@ -586,6 +519,20 @@ function isaffine(sys::AbstractSystem)
     all(isaffine(r, states(sys)) for r in rhs)
 end
 
+function time_varying_as_func(x, sys::AbstractTimeDependentSystem)
+    # if something is not x(t) (the current state)
+    # but is `x(t-1)` or something like that, pass in `x` as a callable function rather
+    # than pass in a value in place of x(t).
+    #
+    # This is done by just making `x` the argument of the function.
+    if istree(x) &&
+       operation(x) isa Sym &&
+       !(length(arguments(x)) == 1 && isequal(arguments(x)[1], get_iv(sys)))
+        return operation(x)
+    end
+    return x
+end
+
 struct AbstractSysToExpr
     sys::AbstractSystem
     states::Vector