Merge pull request #84 from control-toolbox/newmodel

Update with new CTModels and CTBase

Author: ocots

Project.toml

@@ -1,12 +1,15 @@
 name = "CTFlows"
 uuid = "1c39547c-7794-42f7-af83-d98194f657c2"
 authors = ["Olivier Cots <olivier.cots@toulouse-inp.fr>"]
-version = "0.7.0"
+version = "0.8.0"
 
 [deps]
 CTBase = "54762871-cc72-4466-b8e8-f6c8b58076cd"
+CTModels = "34c4fa32-2049-4079-8329-de33c2a22e2d"
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
+ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210"
 MLStyle = "d8e11817-5142-5d16-987a-aa16d5891078"
+MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
 
 [weakdeps]
 OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed"
@@ -15,8 +18,11 @@ OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed"
 CTFlowsODE = "OrdinaryDiffEq"
 
 [compat]
-CTBase = "0.14"
+CTBase = "0.15"
+CTModels = "0.2"
 DocStringExtensions = "0.9"
+ForwardDiff = "0.10"
 MLStyle = "0.4"
+MacroTools = "0.5"
 OrdinaryDiffEq = "6"
 julia = "1.10"

ext/CTFlowsODE.jl

@@ -2,19 +2,20 @@ module CTFlowsODE
 
 using CTBase
 using CTFlows
+using CTModels
 using OrdinaryDiffEq
 using DocStringExtensions
 using MLStyle
 #
 import CTFlows: Flow, CTFlows
 import Base: *
-import CTBase: OptimalControlSolution, CTBase
+import CTModels: Solution, CTModels
 
 # --------------------------------------------------------------------------------------------------
 # Aliases
-const CoTangent = ctVector
-const DCoTangent = ctVector
-const ctgradient = CTBase.__ctgradient
+const CoTangent  = CTFlows.ctVector
+const DCoTangent = CTFlows.ctVector
+const ctgradient = CTFlows.ctgradient
 
 # types
 abstract type AbstractFlow{D,U} end
@@ -25,6 +26,10 @@ const __create_hamiltonian = CTFlows.__create_hamiltonian
 #
 rg(i::Int, j::Int) = i == j ? i : i:j
 
+#
+const __autonomous = CTFlows.__autonomous
+const __variable = CTFlows.__variable
+
 # --------------------------------------------------------------------------------------------#
 include("default.jl")
 include("types.jl")

ext/concatenation.jl

@@ -32,7 +32,7 @@ function __concat_feedback_control(F::AbstractFlow, G::AbstractFlow, t_switch::T
             G.feedback_control(t, x, u, v)
         end
     end
-    feedback_control = ControlLaw(_feedback_control, NonAutonomous, NonFixed)
+    feedback_control = CTFlows.ControlLaw(_feedback_control, CTFlows.NonAutonomous, CTFlows.NonFixed)
     return feedback_control
 end
 

ext/default.jl

@@ -17,16 +17,16 @@ Default variable from ocp.
 """
 function __variable(t0, x0, p0, tf, ocp)
     # if tf is free and ocp has only one variable, then return tf
-    CTBase.has_free_final_time(ocp) && CTBase.variable_dimension(ocp) == 1 && return tf
+    CTModels.has_free_final_time(ocp) && CTModels.variable_dimension(ocp) == 1 && return tf
 
     # if t0 is free and ocp has only one variable, then return t0
-    CTBase.has_free_initial_time(ocp) && CTBase.variable_dimension(ocp) == 1 && return t0
+    CTModels.has_free_initial_time(ocp) && CTModels.variable_dimension(ocp) == 1 && return t0
 
     # if t0 and tf are free and ocp has only two variables, then return [t0, tf]
-    CTBase.has_free_final_time(ocp) &&
-        CTBase.has_free_initial_time(ocp) &&
-        CTBase.variable_dimension(ocp) == 2 &&
-        return [t0, tf]
+    CTModels.has_free_final_time(ocp) &&
+    CTModels.has_free_initial_time(ocp) &&
+    CTModels.variable_dimension(ocp) == 2 &&
+    return [t0, tf]
 
     # otherwise return an empty vector of right type to avoid warning performance message from OrdinaryDiffEq
     z0 = [x0; p0]

ext/function.jl

@@ -55,8 +55,8 @@ end
 # --------------------------------------------------------------------------------------------
 function CTFlows.Flow(
     dyn::Function;
-    autonomous=true,
-    variable=false,
+    autonomous=__autonomous(),
+    variable=__variable(),
     alg=__alg(),
     abstol=__abstol(),
     reltol=__reltol(),

ext/hamiltonian.jl

@@ -64,7 +64,7 @@ $(TYPEDSIGNATURES)
 
 The right and side from a Hamiltonian.
 """
-function rhs(h::AbstractHamiltonian)
+function rhs(h::CTFlows.AbstractHamiltonian)
     function rhs!(dz::DCoTangent, z::CoTangent, v::Variable, t::Time)
         n = size(z, 1) ÷ 2
         foo(z) = h(t, z[rg(1, n)], z[rg(n + 1, 2n)], v)
@@ -78,7 +78,7 @@ end
 # --------------------------------------------------------------------------------------------
 # Flow from a Hamiltonian
 function CTFlows.Flow(
-    h::AbstractHamiltonian;
+    h::CTFlows.AbstractHamiltonian;
     alg=__alg(),
     abstol=__abstol(),
     reltol=__reltol(),
@@ -94,7 +94,7 @@ end
 # --------------------------------------------------------------------------------------------
 # Flow from a Hamiltonian Vector Field
 function CTFlows.Flow(
-    hv::HamiltonianVectorField;
+    hv::CTFlows.HamiltonianVectorField;
     alg=__alg(),
     abstol=__abstol(),
     reltol=__reltol(),

ext/optimal_control_problem.jl

@@ -15,18 +15,33 @@ julia> f = Flow(ocp, (x, p) -> p)
     The dimension of the output of the control function must be consistent with the dimension usage of the control of the optimal control problem.
 """
 function CTFlows.Flow(
-    ocp::OptimalControlModel{T,V},
-    u_::Union{Function,ControlLaw{<:Function,T,V}};
+    ocp::CTModels.Model,
+    u_::CTFlows.ControlLaw;
     alg=__alg(),
     abstol=__abstol(),
     reltol=__reltol(),
     saveat=__saveat(),
     kwargs_Flow...,
-) where {T,V}
+)
     h, u = __create_hamiltonian(ocp, u_) # construction of the Hamiltonian
     return __ocp_Flow(ocp, h, u, alg, abstol, reltol, saveat; kwargs_Flow...)
 end
 
+function CTFlows.Flow(
+    ocp::CTModels.Model,
+    u_::Function;
+    autonomous::Bool=__autonomous(),
+    variable::Bool=__variable(ocp),
+    alg=__alg(),
+    abstol=__abstol(),
+    reltol=__reltol(),
+    saveat=__saveat(),
+    kwargs_Flow...,
+)
+    h, u = __create_hamiltonian(ocp, u_; autonomous=autonomous, variable=variable) # construction of the Hamiltonian
+    return __ocp_Flow(ocp, h, u, alg, abstol, reltol, saveat; kwargs_Flow...)
+end
+
 # ---------------------------------------------------------------------------------------------------
 """
 $(TYPEDSIGNATURES)
@@ -46,10 +61,10 @@ julia> f = Flow(ocp, (t, x, p) -> p[1], (t, x, u) -> x[1] - 1, (t, x, p) -> x[1]
     The dimension of the output of the control function must be consistent with the dimension usage of the control of the optimal control problem.
 """
 function CTFlows.Flow(
-    ocp::OptimalControlModel{T,V},
-    u_::Union{Function,ControlLaw{<:Function,T,V},FeedbackControl{<:Function,T,V}},
-    g_::Union{Function,MixedConstraint{<:Function,T,V},StateConstraint{<:Function,T,V}},
-    μ_::Union{Function,Multiplier{<:Function,T,V}};
+    ocp::CTModels.Model,
+    u_::Union{CTFlows.ControlLaw{<:Function,T,V},CTFlows.FeedbackControl{<:Function,T,V}},
+    g_::Union{CTFlows.MixedConstraint{<:Function,T,V},CTFlows.StateConstraint{<:Function,T,V}},
+    μ_::Union{CTFlows.Multiplier{<:Function,T,V}};
     alg=__alg(),
     abstol=__abstol(),
     reltol=__reltol(),
@@ -60,17 +75,34 @@ function CTFlows.Flow(
     return __ocp_Flow(ocp, h, u, alg, abstol, reltol, saveat; kwargs_Flow...)
 end
 
+function CTFlows.Flow(
+    ocp::CTModels.Model,
+    u_::Function,
+    g_::Function,
+    μ_::Function;
+    autonomous::Bool=__autonomous(),
+    variable::Bool=__variable(ocp),
+    alg=__alg(),
+    abstol=__abstol(),
+    reltol=__reltol(),
+    saveat=__saveat(),
+    kwargs_Flow...,
+)
+    h, u = __create_hamiltonian(ocp, u_, g_, μ_; autonomous=autonomous, variable=variable) # construction of the Hamiltonian
+    return __ocp_Flow(ocp, h, u, alg, abstol, reltol, saveat; kwargs_Flow...)
+end
+
 # ---------------------------------------------------------------------------------------------------
 function __ocp_Flow(
-    ocp::OptimalControlModel{T,V},
-    h::Hamiltonian,
-    u::ControlLaw,
+    ocp::CTModels.Model,
+    h::CTFlows.Hamiltonian,
+    u::CTFlows.ControlLaw,
     alg,
     abstol,
     reltol,
     saveat;
     kwargs_Flow...,
-) where {T,V}
+)
     rhs! = rhs(h) # right and side: same as for a flow from a Hamiltonian
     f = hamiltonian_usage(alg, abstol, reltol, saveat; kwargs_Flow...) # flow function
     kwargs_Flow = (kwargs_Flow..., alg=alg, abstol=abstol, reltol=reltol, saveat=saveat)