rename Control -> DynamicOpt

Author: vyudu

Project.toml

@@ -78,7 +78,7 @@ MTKChainRulesCoreExt = "ChainRulesCore"
 MTKDeepDiffsExt = "DeepDiffs"
 MTKFMIExt = "FMI"
 MTKInfiniteOptExt = "InfiniteOpt"
-MTKJuMPControlExt = ["JuMP", "DiffEqDevTools", "InfiniteOpt"]
+MTKJuMPDynamicOptExt = ["JuMP", "DiffEqDevTools", "InfiniteOpt"]
 MTKLabelledArraysExt = "LabelledArrays"
 
 [compat]

ext/MTKJuMPControlExt.jl renamed to ext/MTKJuMPDynamicOptExt.jl

@@ -1,43 +1,43 @@
-module MTKJuMPControlExt
+module MTKJuMPDynamicOptExt
 using ModelingToolkit
 using JuMP, InfiniteOpt
 using DiffEqDevTools, DiffEqBase
 using LinearAlgebra
 using StaticArrays
 const MTK = ModelingToolkit
 
-struct JuMPControlProblem{uType, tType, isinplace, P, F, K} <:
-       AbstractOptimalControlProblem{uType, tType, isinplace}
+struct JuMPDynamicOptProblem{uType, tType, isinplace, P, F, K} <:
+       AbstractDynamicOptProblem{uType, tType, isinplace}
     f::F
     u0::uType
     tspan::tType
     p::P
     model::InfiniteModel
     kwargs::K
 
-    function JuMPControlProblem(f, u0, tspan, p, model, kwargs...)
+    function JuMPDynamicOptProblem(f, u0, tspan, p, model, kwargs...)
         new{typeof(u0), typeof(tspan), SciMLBase.isinplace(f, 5),
             typeof(p), typeof(f), typeof(kwargs)}(f, u0, tspan, p, model, kwargs)
     end
 end
 
-struct InfiniteOptControlProblem{uType, tType, isinplace, P, F, K} <:
-       AbstractOptimalControlProblem{uType, tType, isinplace}
+struct InfiniteOptDynamicOptProblem{uType, tType, isinplace, P, F, K} <:
+       AbstractDynamicOptProblem{uType, tType, isinplace}
     f::F
     u0::uType
     tspan::tType
     p::P
     model::InfiniteModel
     kwargs::K
 
-    function InfiniteOptControlProblem(f, u0, tspan, p, model, kwargs...)
+    function InfiniteOptDynamicOptProblem(f, u0, tspan, p, model, kwargs...)
         new{typeof(u0), typeof(tspan), SciMLBase.isinplace(f),
             typeof(p), typeof(f), typeof(kwargs)}(f, u0, tspan, p, model, kwargs)
     end
 end
 
 """
-    JuMPControlProblem(sys::ODESystem, u0, tspan, p; dt)
+    JuMPDynamicOptProblem(sys::ODESystem, u0, tspan, p; dt)
 
 Convert an ODESystem representing an optimal control system into a JuMP model
 for solving using optimization. Must provide either `dt`, the timestep between collocation 
@@ -52,7 +52,7 @@ The constraints are:
 - The set of user constraints passed to the ODESystem via `constraints`
 - The solver constraints that encode the time-stepping used by the solver
 """
-function MTK.JuMPControlProblem(sys::ODESystem, u0map, tspan, pmap;
+function MTK.JuMPDynamicOptProblem(sys::ODESystem, u0map, tspan, pmap;
         dt = nothing,
         steps = nothing,
         guesses = Dict(), kwargs...)
@@ -65,20 +65,20 @@ function MTK.JuMPControlProblem(sys::ODESystem, u0map, tspan, pmap;
     steps, is_free_t = MTK.process_tspan(tspan, dt, steps)
     model = init_model(sys, tspan, steps, u0map, pmap, u0; is_free_t)
 
-    JuMPControlProblem(f, u0, tspan, p, model, kwargs...)
+    JuMPDynamicOptProblem(f, u0, tspan, p, model, kwargs...)
 end
 
 """
-    InfiniteOptControlProblem(sys::ODESystem, u0map, tspan, pmap; dt)
+    InfiniteOptDynamicOptProblem(sys::ODESystem, u0map, tspan, pmap; dt)
 
 Convert an ODESystem representing an optimal control system into a InfiniteOpt model
 for solving using optimization. Must provide `dt` for determining the length 
 of the interpolation arrays.
 
-Related to `JuMPControlProblem`, but directly adds the differential equations
+Related to `JuMPDynamicOptProblem`, but directly adds the differential equations
 of the system as derivative constraints, rather than using a solver tableau.
 """
-function MTK.InfiniteOptControlProblem(sys::ODESystem, u0map, tspan, pmap;
+function MTK.InfiniteOptDynamicOptProblem(sys::ODESystem, u0map, tspan, pmap;
         dt = nothing,
         steps = nothing,
         guesses = Dict(), kwargs...)
@@ -92,7 +92,7 @@ function MTK.InfiniteOptControlProblem(sys::ODESystem, u0map, tspan, pmap;
     model = init_model(sys, tspan, steps, u0map, pmap, u0; is_free_t)
 
     add_infopt_solve_constraints!(model, sys, pmap; is_free_t)
-    InfiniteOptControlProblem(f, u0, tspan, p, model, kwargs...)
+    InfiniteOptDynamicOptProblem(f, u0, tspan, p, model, kwargs...)
 end
 
 # Initialize InfiniteOpt model.
@@ -307,16 +307,16 @@ function add_jump_solve_constraints!(prob, tableau; is_free_t = false)
 end
 
 """
-Solve JuMPControlProblem. Arguments:
-- prob: a JumpControlProblem
+Solve JuMPDynamicOptProblem. Arguments:
+- prob: a JumpDynamicOptProblem
 - jump_solver: a LP solver such as HiGHS
 - ode_solver: Takes in a symbol representing the solver. Acceptable solvers may be found at https://docs.sciml.ai/DiffEqDevDocs/stable/internals/tableaus/. Note that the symbol may be different than the typical name of the solver, e.g. :Tsitouras5 rather than Tsit5.
 - silent: set the model silent (suppress model output)
 
-Returns a JuMPControlSolution, which contains both the model and the ODE solution.
+Returns a DynamicOptSolution, which contains both the model and the ODE solution.
 """
 function DiffEqBase.solve(
-        prob::JuMPControlProblem, jump_solver, ode_solver::Symbol; silent = false)
+        prob::JuMPDynamicOptProblem, jump_solver, ode_solver::Symbol; silent = false)
     model = prob.model
     tableau_getter = Symbol(:construct, ode_solver)
     @eval tableau = $tableau_getter()
@@ -343,15 +343,15 @@ end
 """
 `derivative_method` kwarg refers to the method used by InfiniteOpt to compute derivatives. The list of possible options can be found at https://infiniteopt.github.io/InfiniteOpt.jl/stable/guide/derivative/. Defaults to FiniteDifference(Backward()).
 """
-function DiffEqBase.solve(prob::InfiniteOptControlProblem, jump_solver;
+function DiffEqBase.solve(prob::InfiniteOptDynamicOptProblem, jump_solver;
         derivative_method = InfiniteOpt.FiniteDifference(Backward()), silent = false)
     model = prob.model
     silent && set_silent(model)
     set_derivative_method(model[:t], derivative_method)
     _solve(prob, jump_solver, derivative_method)
 end
 
-function _solve(prob::AbstractOptimalControlProblem, jump_solver, solver)
+function _solve(prob::AbstractDynamicOptProblem, jump_solver, solver)
     model = prob.model
     set_optimizer(model, jump_solver)
     optimize!(model)
@@ -382,7 +382,7 @@ function _solve(prob::AbstractOptimalControlProblem, jump_solver, solver)
             input_sol, SciMLBase.ReturnCode.ConvergenceFailure))
     end
 
-    OptimalControlSolution(model, sol, input_sol)
+    DynamicOptSolution(model, sol, input_sol)
 end
 
 end

src/ModelingToolkit.jl

@@ -349,9 +349,9 @@ export AnalysisPoint, get_sensitivity_function, get_comp_sensitivity_function,
 function FMIComponent end
 
 include("systems/optimal_control_interface.jl")
-export AbstractOptimalControlProblem, JuMPControlProblem, InfiniteOptControlProblem,
-       PyomoControlProblem, CasADiControlProblem
-export OptimalControlSolution
+export AbstractDynamicOptProblem, JuMPDynamicOptProblem, InfiniteOptDynamicOptProblem,
+       PyomoDynamicOptProblem, CasADiDynamicOptProblem
+export DynamicOptSolution 
 export ∫
 
 end # module

src/systems/optimal_control_interface.jl

@@ -1,13 +1,13 @@
-abstract type AbstractOptimalControlProblem{uType, tType, isinplace} <:
+abstract type AbstractDynamicOptProblem{uType, tType, isinplace} <:
               SciMLBase.AbstractODEProblem{uType, tType, isinplace} end
 
-struct OptimalControlSolution
+struct DynamicOptSolution
     model::Any
     sol::ODESolution
     input_sol::Union{Nothing, ODESolution}
 end
 
-function Base.show(io::IO, sol::OptimalControlSolution)
+function Base.show(io::IO, sol::DynamicOptSolution)
     println("retcode: ", sol.sol.retcode, "\n")
 
     println("Optimal control solution for following model:\n")
@@ -16,10 +16,10 @@ function Base.show(io::IO, sol::OptimalControlSolution)
     print("\n\nPlease query the model using sol.model, the solution trajectory for the system using sol.sol, or the solution trajectory for the controllers using sol.input_sol.")
 end
 
-function JuMPControlProblem end
-function InfiniteOptControlProblem end
-function CasADiControlProblem end
-function PyomoControlProblem end
+function JuMPDynamicOptProblem end
+function InfiniteOptDynamicOptProblem end
+function CasADiDynamicOptProblem end
+function PyomoDynamicOptProblem end
 
 function warn_overdetermined(sys, u0map)
     constraintsys = get_constraintsystem(sys)

test/downstream/Project.toml

@@ -4,6 +4,7 @@ LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78"
 ModelingToolkitStandardLibrary = "16a59e39-deab-5bd0-87e4-056b12336739"
 OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed"
+OrdinaryDiffEqNonlinearSolve = "127b3ac7-2247-4354-8eb6-78cf4e7c58e8"
 SymbolicIndexingInterface = "2efcf032-c050-4f8e-a9bb-153293bab1f5"
 
 [compat]

test/dynamic_optimization/jump_control.jl

@@ -23,7 +23,7 @@ using DataInterpolations
     parammap = [α => 1.5, β => 1.0, γ => 3.0, δ => 1.0]
 
     # Test explicit method.
-    jprob = JuMPControlProblem(sys, u0map, tspan, parammap, dt = 0.01)
+    jprob = JuMPDynamicOptProblem(sys, u0map, tspan, parammap, dt = 0.01)
     @test JuMP.num_constraints(jprob.model) == 2 # initials
     jsol = solve(jprob, Ipopt.Optimizer, :RK4)
     oprob = ODEProblem(sys, u0map, tspan, parammap)
@@ -34,7 +34,7 @@ using DataInterpolations
     jsol2 = solve(jprob, Ipopt.Optimizer, :ImplicitEuler, silent = true) # 63.031 ms, 26.49 MiB
     osol2 = solve(oprob, ImplicitEuler(), dt = 0.01, adaptive = false) # 129.375 μs, 61.91 KiB
     @test ≈(jsol2.sol.u, osol2.u, rtol = 0.001)
-    iprob = InfiniteOptControlProblem(sys, u0map, tspan, parammap, dt = 0.01)
+    iprob = InfiniteOptDynamicOptProblem(sys, u0map, tspan, parammap, dt = 0.01)
     isol = solve(iprob, Ipopt.Optimizer,
         derivative_method = InfiniteOpt.FiniteDifference(InfiniteOpt.Backward()),
         silent = true) # 11.540 ms, 4.00 MiB
@@ -46,13 +46,13 @@ using DataInterpolations
     constr = [x(0.6) ~ 3.5, x(0.3) ~ 7.0]
     @mtkbuild lksys = ODESystem(eqs, t; constraints = constr)
 
-    jprob = JuMPControlProblem(lksys, u0map, tspan, parammap; guesses = guess, dt = 0.01)
+    jprob = JuMPDynamicOptProblem(lksys, u0map, tspan, parammap; guesses = guess, dt = 0.01)
     @test JuMP.num_constraints(jprob.model) == 2
     jsol = solve(jprob, Ipopt.Optimizer, :Tsitouras5, silent = true) # 12.190 s, 9.68 GiB
     @test jsol.sol(0.6)[1] ≈ 3.5
     @test jsol.sol(0.3)[1] ≈ 7.0
 
-    iprob = InfiniteOptControlProblem(
+    iprob = InfiniteOptDynamicOptProblem(
         lksys, u0map, tspan, parammap; guesses = guess, dt = 0.01)
     isol = solve(iprob, Ipopt.Optimizer,
         derivative_method = InfiniteOpt.OrthogonalCollocation(3), silent = true) # 48.564 ms, 9.58 MiB
@@ -63,13 +63,13 @@ using DataInterpolations
     # Test whole-interval constraints
     constr = [x(t) ≳ 1, y(t) ≳ 1]
     @mtkbuild lksys = ODESystem(eqs, t; constraints = constr)
-    iprob = InfiniteOptControlProblem(
+    iprob = InfiniteOptDynamicOptProblem(
         lksys, u0map, tspan, parammap; guesses = guess, dt = 0.01)
     isol = solve(iprob, Ipopt.Optimizer,
         derivative_method = InfiniteOpt.OrthogonalCollocation(3), silent = true) # 48.564 ms, 9.58 MiB
     @test all(u -> u > [1, 1], isol.sol.u)
 
-    jprob = JuMPControlProblem(lksys, u0map, tspan, parammap; guesses = guess, dt = 0.01)
+    jprob = JuMPDynamicOptProblem(lksys, u0map, tspan, parammap; guesses = guess, dt = 0.01)
     jsol = solve(jprob, Ipopt.Optimizer, :RadauIA3, silent = true) # 12.190 s, 9.68 GiB
     @test all(u -> u > [1, 1], jsol.sol.u)
 end
@@ -103,7 +103,7 @@ end
     u0map = [x(t) => 0.0, v(t) => 0.0]
     tspan = (0.0, 1.0)
     parammap = [u(t) => 0.0]
-    jprob = JuMPControlProblem(block, u0map, tspan, parammap; dt = 0.01)
+    jprob = JuMPDynamicOptProblem(block, u0map, tspan, parammap; dt = 0.01)
     jsol = solve(jprob, Ipopt.Optimizer, :Verner8)
     # Linear systems have bang-bang controls
     @test is_bangbang(jsol.input_sol, [-1.0], [1.0])
@@ -117,7 +117,7 @@ end
     osol = solve(oprob, Vern8(), dt = 0.01, adaptive = false)
     @test ≈(jsol.sol.u, osol.u, rtol = 0.05)
 
-    iprob = InfiniteOptControlProblem(block, u0map, tspan, parammap; dt = 0.01)
+    iprob = InfiniteOptDynamicOptProblem(block, u0map, tspan, parammap; dt = 0.01)
     isol = solve(iprob, Ipopt.Optimizer; silent = true)
     @test is_bangbang(isol.input_sol, [-1.0], [1.0])
     @test ≈(isol.sol.u[end][1], 0.25, rtol = 1e-5)
@@ -141,10 +141,10 @@ end
     u0map = [w(t) => 40, q(t) => 2]
     pmap = [b => 1, c => 1, μ => 1, s => 1, ν => 1, α => 1]
 
-    jprob = JuMPControlProblem(beesys, u0map, tspan, pmap, dt = 0.01)
+    jprob = JuMPDynamicOptProblem(beesys, u0map, tspan, pmap, dt = 0.01)
     jsol = solve(jprob, Ipopt.Optimizer, :Tsitouras5)
     @test is_bangbang(jsol.input_sol, [0.0], [1.0])
-    iprob = InfiniteOptControlProblem(beesys, u0map, tspan, pmap, dt = 0.01)
+    iprob = InfiniteOptDynamicOptProblem(beesys, u0map, tspan, pmap, dt = 0.01)
     isol = solve(iprob, Ipopt.Optimizer; silent = true)
     @test is_bangbang(isol.input_sol, [0.0], [1.0])
 
@@ -186,11 +186,11 @@ end
     pmap = [
         g₀ => 1, m₀ => 1.0, h_c => 500, c => 0.5 * √(g₀ * h₀), D_c => 0.5 * 620 * m₀ / g₀,
         Tₘ => 3.5 * g₀ * m₀, T(t) => 0.0, h₀ => 1, m_c => 0.6]
-    jprob = JuMPControlProblem(rocket, u0map, (ts, te), pmap; dt = 0.005, cse = false)
+    jprob = JuMPDynamicOptProblem(rocket, u0map, (ts, te), pmap; dt = 0.005, cse = false)
     jsol = solve(jprob, Ipopt.Optimizer, :RadauIIA5, silent = true)
     @test jsol.sol.u[end][1] > 1.012
 
-    iprob = InfiniteOptControlProblem(
+    iprob = InfiniteOptDynamicOptProblem(
         rocket, u0map, (ts, te), pmap; dt = 0.005, cse = false)
     isol = solve(iprob, Ipopt.Optimizer,
         derivative_method = InfiniteOpt.OrthogonalCollocation(3), silent = true)
@@ -223,11 +223,11 @@ end
 
     u0map = [x(t) => 17.5]
     pmap = [u(t) => 0.0, tf => 8]
-    jprob = JuMPControlProblem(rocket, u0map, (0, tf), pmap; steps = 201)
+    jprob = JuMPDynamicOptProblem(rocket, u0map, (0, tf), pmap; steps = 201)
     jsol = solve(jprob, Ipopt.Optimizer, :Tsitouras5)
     @test isapprox(jsol.sol.t[end], 10.0, rtol = 1e-3)
 
-    iprob = InfiniteOptControlProblem(rocket, u0map, (0, tf), pmap; steps = 200)
+    iprob = InfiniteOptDynamicOptProblem(rocket, u0map, (0, tf), pmap; steps = 200)
     isol = solve(iprob, Ipopt.Optimizer)
     @test isapprox(isol.sol.t[end], 10.0, rtol = 1e-3)
 end
@@ -259,11 +259,11 @@ end
 
     u0map = [D(x(t)) => 0.0, D(θ(t)) => 0.0, θ(t) => 0.0, x(t) => 0.0]
     pmap = [mₖ => 1.0, mₚ => 0.2, l => 0.5, g => 9.81, u => 0]
-    jprob = JuMPControlProblem(cartpole, u0map, tspan, pmap; dt = 0.04)
+    jprob = JuMPDynamicOptProblem(cartpole, u0map, tspan, pmap; dt = 0.04)
     jsol = solve(jprob, Ipopt.Optimizer, :RK4)
     @test jsol.sol.u[end] ≈ [π, 0, 0, 0]
 
-    iprob = InfiniteOptControlProblem(cartpole, u0map, tspan, pmap; dt = 0.04)
+    iprob = InfiniteOptDynamicOptProblem(cartpole, u0map, tspan, pmap; dt = 0.04)
     isol = solve(iprob, Ipopt.Optimizer)
     @test isol.sol.u[end] ≈ [π, 0, 0, 0]
 end

test/extensions/ad.jl

@@ -4,6 +4,7 @@ using Zygote
 using SymbolicIndexingInterface
 using SciMLStructures
 using OrdinaryDiffEqTsit5
+using OrdinaryDiffEqNonlinearSolve
 using NonlinearSolve
 using SciMLSensitivity
 using ForwardDiff