added : additionnal MPC kargs are passed to estimator

Author: franckgaga

src/controller/explicitmpc.jl

@@ -95,6 +95,7 @@ state estimator, a [`SteadyKalmanFilter`](@ref) with default arguments.
 - `Nwt=fill(0.1,model.nu)` : main diagonal of ``\mathbf{N}`` weight matrix (vector).
 - `Lwt=fill(0.0,model.nu)` : main diagonal of ``\mathbf{L}`` weight matrix (vector).
 - `ru=model.uop` : manipulated input setpoints ``\mathbf{r_u}`` (vector).
+- additionnal keyword arguments are passed to [`SteadyKalmanFilter`](@ref) constructor.
 
 # Examples
 ```jldoctest
@@ -112,7 +113,19 @@ ExplicitMPC controller with a sample time Ts = 4.0 s, SteadyKalmanFilter estimat
 ```
 
 """
-ExplicitMPC(model::LinModel; kwargs...) = ExplicitMPC(SteadyKalmanFilter(model); kwargs...)
+function ExplicitMPC(
+    model::LinModel; 
+    Hp::Union{Int, Nothing} = nothing,
+    Hc::Int = DEFAULT_HC,
+    Mwt = fill(DEFAULT_MWT, model.ny),
+    Nwt = fill(DEFAULT_NWT, model.nu),
+    Lwt = fill(DEFAULT_LWT, model.nu),
+    ru  = model.uop,
+    kwargs...
+) 
+    estim = SteadyKalmanFilter(model; kwargs...)
+    return ExplicitMPC(estim; Hp, Hc, Mwt, Nwt, Lwt, ru)
+end
 
 """
     ExplicitMPC(estim::StateEstimator; <keyword arguments>)
@@ -139,17 +152,17 @@ ExplicitMPC controller with a sample time Ts = 4.0 s, KalmanFilter estimator and
 function ExplicitMPC(
     estim::S;
     Hp::Union{Int, Nothing} = nothing,
-    Hc::Int = 2,
-    Mwt = fill(1.0, estim.model.ny),
-    Nwt = fill(0.1, estim.model.nu),
-    Lwt = fill(0.0, estim.model.nu),
+    Hc::Int = DEFAULT_HC,
+    Mwt = fill(DEFAULT_MWT, estim.model.ny),
+    Nwt = fill(DEFAULT_NWT, estim.model.nu),
+    Lwt = fill(DEFAULT_LWT, estim.model.nu),
     ru  = estim.model.uop,
 ) where {S<:StateEstimator}
     isa(estim.model, LinModel) || error("estim.model type must be LinModel") 
     poles = eigvals(estim.model.A)
     nk = sum(poles .≈ 0)
     if isnothing(Hp)
-        Hp = 10 + nk
+        Hp = DEFAULT_HP + nk
     end
     if Hp ≤ nk
         @warn("prediction horizon Hp ($Hp) ≤ number of delays in model "*

src/controller/linmpc.jl

@@ -111,6 +111,7 @@ arguments.
 - `optim=JuMP.Model(OSQP.MathOptInterfaceOSQP.Optimizer)` : quadratic optimizer used in
   the predictive controller, provided as a [`JuMP.Model`](https://jump.dev/JuMP.jl/stable/reference/models/#JuMP.Model)
   (default to [`OSQP.jl`](https://osqp.org/docs/parsers/jump.html) optimizer).
+- additionnal keyword arguments are passed to [`SteadyKalmanFilter`](@ref) constructor.
 
 # Examples
 ```jldoctest
@@ -149,7 +150,21 @@ The objective function follows this nomenclature:
 | ``C``            | slack variable weight                              | `()`             |
 | ``ϵ``            | slack variable for constraint softening            | `()`             |
 """
-LinMPC(model::LinModel; kwargs...) = LinMPC(SteadyKalmanFilter(model); kwargs...)
+function LinMPC(
+    model::LinModel;
+    Hp::Union{Int, Nothing} = nothing,
+    Hc::Int = DEFAULT_HC,
+    Mwt = fill(DEFAULT_MWT, model.ny),
+    Nwt = fill(DEFAULT_NWT, model.nu),
+    Lwt = fill(DEFAULT_LWT, model.nu),
+    Cwt = DEFAULT_CWT,
+    ru  = model.uop,
+    optim::JuMP.Model = JuMP.Model(OSQP.MathOptInterfaceOSQP.Optimizer),
+    kwargs...
+)
+    estim = SteadyKalmanFilter(model; kwargs...)
+    return LinMPC(estim; Hp, Hc, Mwt, Nwt, Lwt, Cwt, ru, optim)
+end
 
 
 """
@@ -176,20 +191,20 @@ LinMPC controller with a sample time Ts = 4.0 s, OSQP optimizer, KalmanFilter es
 """
 function LinMPC(
     estim::S;
-    Hp::Union{Int, Nothing} = nothing,
-    Hc::Int = 2,
-    Mwt = fill(1.0, estim.model.ny),
-    Nwt = fill(0.1, estim.model.nu),
-    Lwt = fill(0.0, estim.model.nu),
-    Cwt = 1e5,
+    Hp::Union{Int, Nothing} = DEFAULT_HP,
+    Hc::Int = DEFAULT_HC,
+    Mwt = fill(DEFAULT_MWT, estim.model.ny),
+    Nwt = fill(DEFAULT_NWT, estim.model.nu),
+    Lwt = fill(DEFAULT_LWT, estim.model.nu),
+    Cwt = DEFAULT_CWT,
     ru  = estim.model.uop,
     optim::JuMP.Model = JuMP.Model(OSQP.MathOptInterfaceOSQP.Optimizer)
 ) where {S<:StateEstimator}
     isa(estim.model, LinModel) || error("estim.model type must be LinModel") 
     poles = eigvals(estim.model.A)
     nk = sum(poles .≈ 0)
     if isnothing(Hp)
-        Hp = 10 + nk
+        Hp = DEFAULT_HP + nk
     end
     if Hp ≤ nk
         @warn("prediction horizon Hp ($Hp) ≤ number of delays in model "*

src/controller/nonlinmpc.jl

@@ -125,6 +125,8 @@ This method uses the default state estimator :
 - `optim=JuMP.Model(Ipopt.Optimizer)` : nonlinear optimizer used in the predictive
    controller, provided as a [`JuMP.Model`](https://jump.dev/JuMP.jl/stable/reference/models/#JuMP.Model)
    (default to [`Ipopt.jl`](https://github.com/jump-dev/Ipopt.jl) optimizer).
+- additionnal keyword arguments are passed to [`UnscentedKalmanFilter`](@ref) constructor 
+  (or [`SteadyKalmanFilter`](@ref), for [`LinModel`](@ref)).
 
 # Examples
 ```jldoctest
@@ -152,8 +154,40 @@ generally benefit from exact derivatives like AD. However, the [`NonLinModel`](@
 and `h` functions must be compatible with this feature. See [Automatic differentiation](https://jump.dev/JuMP.jl/stable/manual/nlp/#Automatic-differentiation)
 for common mistakes when writing these functions.
 """
-NonLinMPC(model::SimModel; kwargs...) = NonLinMPC(UnscentedKalmanFilter(model); kwargs...)
-NonLinMPC(model::LinModel; kwargs...) = NonLinMPC(SteadyKalmanFilter(model); kwargs...)
+function NonLinMPC(
+    model::SimModel;
+    Hp::Int = DEFAULT_HP,
+    Hc::Int = DEFAULT_HC,
+    Mwt = fill(DEFAULT_MWT, model.ny),
+    Nwt = fill(DEFAULT_NWT, model.nu),
+    Lwt = fill(DEFAULT_LWT, model.nu),
+    Cwt = DEFAULT_CWT,
+    Ewt = DEFAULT_EWT,
+    JE::Function = (_,_,_) -> 0.0,
+    ru  = model.uop,
+    optim::JuMP.Model = JuMP.Model(optimizer_with_attributes(Ipopt.Optimizer,"sb"=>"yes")),
+    kwargs...
+)
+    estim = UnscentedKalmanFilter(model; kwargs...)
+    NonLinMPC(estim; Hp, Hc, Mwt, Nwt, Lwt, Cwt, Ewt, JE, ru, optim)
+end
+function NonLinMPC(
+    model::LinModel;
+    Hp::Int = DEFAULT_HP,
+    Hc::Int = DEFAULT_HC,
+    Mwt = fill(DEFAULT_MWT, model.ny),
+    Nwt = fill(DEFAULT_NWT, model.nu),
+    Lwt = fill(DEFAULT_LWT, model.nu),
+    Cwt = DEFAULT_CWT,
+    Ewt = DEFAULT_EWT,
+    JE::Function = (_,_,_) -> 0.0,
+    ru  = model.uop,
+    optim::JuMP.Model = JuMP.Model(optimizer_with_attributes(Ipopt.Optimizer,"sb"=>"yes")),
+    kwargs...
+)
+    estim = SteadyKalmanFilter(model; kwargs...)
+    NonLinMPC(estim; Hp, Hc, Mwt, Nwt, Lwt, Cwt, Ewt, JE, ru, optim)
+end
 
 
 """
@@ -180,13 +214,13 @@ NonLinMPC controller with a sample time Ts = 10.0 s, Ipopt optimizer, UnscentedK
 """
 function NonLinMPC(
     estim::S;
-    Hp::Int = 10,
-    Hc::Int = 2,
-    Mwt = fill(1.0, estim.model.ny),
-    Nwt = fill(0.1, estim.model.nu),
-    Lwt = fill(0.0, estim.model.nu),
-    Cwt = 1e5,
-    Ewt = 0.0,
+    Hp::Int = DEFAULT_HP,
+    Hc::Int = DEFAULT_HC,
+    Mwt = fill(DEFAULT_MWT, estim.model.ny),
+    Nwt = fill(DEFAULT_NWT, estim.model.nu),
+    Lwt = fill(DEFAULT_LWT, estim.model.nu),
+    Cwt = DEFAULT_CWT,
+    Ewt = DEFAULT_EWT,
     JE::JEFunc = (_,_,_) -> 0.0,
     ru  = estim.model.uop,
     optim::JuMP.Model = JuMP.Model(optimizer_with_attributes(Ipopt.Optimizer,"sb"=>"yes"))

src/estimator/kalman.jl

@@ -96,11 +96,11 @@ unmeasured ones, for ``\mathbf{Ĉ^u, D̂_d^u}``).
 - `nint_u=0`: integrator quantity for the stochastic model of the unmeasured disturbances at
     the manipulated inputs (vector), use `nint_u=0` for no integrator (see Extended Help).
 - `σQint_u=fill(1,sum(nint_u))`: same than `σQ` but for the unmeasured disturbances at 
-    manipulated inputs ``\mathbf{Q_{int_u}}`` (composed of integrating states).
+    manipulated inputs ``\mathbf{Q_{int_u}}`` (composed of integrators).
 - `nint_ym=default_nint(model,i_ym,nint_u)` : same than `nint_u` but for the unmeasured 
     disturbances at the measured outputs, use `nint_ym=0` for no integrator (see Extended Help).
 - `σQint_ym=fill(1,sum(nint_ym))` : same than `σQ` for the unmeasured disturbances at 
-    measured outputs ``\mathbf{Q_{int_{ym}}}`` (composed of integrating states).
+    measured outputs ``\mathbf{Q_{int_{ym}}}`` (composed of integrators).
 
 # Examples
 ```jldoctest
@@ -240,18 +240,18 @@ Construct a time-varying Kalman Filter with the [`LinModel`](@ref) `model`.
 
 The process model is identical to [`SteadyKalmanFilter`](@ref). The matrix 
 ``\mathbf{P̂}_k(k+1)`` is the estimation error covariance of `model` states augmented with
-the stochastic ones (specified by `nint_ym`). Three keyword arguments modify its initial 
-value with ``\mathbf{P̂}_{-1}(0) = 
+the stochastic ones (specified by `nint_u` and `nint_ym`). Three keyword arguments modify
+its initial value with ``\mathbf{P̂}_{-1}(0) = 
     \mathrm{diag}\{ \mathbf{P}(0), \mathbf{P_{int_{u}}}(0), \mathbf{P_{int_{ym}}}(0) \}``.
 
 # Arguments
 - `model::LinModel` : (deterministic) model for the estimations.
 - `σP0=fill(1/model.nx,model.nx)` : main diagonal of the initial estimate covariance
     ``\mathbf{P}(0)``, specified as a standard deviation vector.
 - `σP0int_u=fill(1,sum(nint_u))` : same than `σP0` but for the unmeasured disturbances at 
-    manipulated inputs ``\mathbf{P_{int_u}}(0)`` (composed of integrating states).
+    manipulated inputs ``\mathbf{P_{int_u}}(0)`` (composed of integrators).
 - `σP0int_ym=fill(1,sum(nint_ym))` : same than `σP0` but for the unmeasured disturbances at 
-    measured outputs ``\mathbf{P_{int_{ym}}}(0)`` (composed of integrating states).
+    measured outputs ``\mathbf{P_{int_{ym}}}(0)`` (composed of integrators).
 - `<keyword arguments>` of [`SteadyKalmanFilter`](@ref) constructor.
 
 # Examples

src/estimator/luenberger.jl

@@ -57,12 +57,12 @@ end
 
 Construct a Luenberger observer with the [`LinModel`](@ref) `model`.
 
-`i_ym` provides the `model` output indices that are measured ``\mathbf{y^m}``, the rest are 
+`i_ym` provides the `model` output indices that are measured ``\mathbf{y^m}``, the rest are
 unmeasured ``\mathbf{y^u}``. `model` matrices are augmented with the stochastic model, which
 is specified by the numbers of integrator `nint_u` and `nint_ym` (see [`SteadyKalmanFilter`](@ref)
-Extended Help). The argument `p̂` is a vector of `model.nx + sum(nint_ym)` elements 
-specifying the observer poles/eigenvalues (near ``z=0.5`` by default). The method computes 
-the observer gain `K̂` with [`place`](https://juliacontrol.github.io/ControlSystems.jl/stable/lib/synthesis/#ControlSystemsBase.place).
+Extended Help). The argument `p̂` is a vector of `model.nx + sum(nint_u) + sum(nint_ym)`
+elements specifying the observer poles/eigenvalues (near ``z=0.5`` by default). The method
+computes the observer gain `K̂` with [`place`](https://juliacontrol.github.io/ControlSystems.jl/stable/lib/synthesis/#ControlSystemsBase.place).
 
 # Examples
 ```jldoctest

src/predictive_control.jl

@@ -19,6 +19,14 @@ julia> u = mpc([5]); round.(u, digits=3)
 """
 abstract type PredictiveController end
 
+const DEFAULT_HP  = 10
+const DEFAULT_HC  = 2
+const DEFAULT_MWT = 1.0
+const DEFAULT_NWT = 0.1
+const DEFAULT_LWT = 0.0
+const DEFAULT_CWT = 1e5
+const DEFAULT_EWT = 0.0
+
 "Type alias for vector of linear inequality constraints."
 const LinConVector = Vector{ConstraintRef{
     Model, 

src/state_estim.jl

@@ -217,10 +217,11 @@ end
 
 Get default integrator quantity per measured outputs `nint_ym` for [`LinModel`](@ref).
 
-The measured output ``\mathbf{y^m}`` indices are specified by `i_ym` argument. By default, 
-one integrator is added on each measured outputs. If ``\mathbf{Â, Ĉ}`` matrices of the 
-augmented model become unobservable, the integrator is removed. This approach works well 
-for stable, integrating and unstable `model` (see Examples).
+The arguments `i_ym` and `nint_u` are the measured output indices and the integrator
+quantity on each manipulated input, respectively. By default, one integrator is added on
+each measured outputs. If ``\mathbf{Â, Ĉ}`` matrices of the augmented model become
+unobservable, the integrator is removed. This approach works well for stable, integrating
+and unstable `model` (see Examples).
 
 # Examples
 ```jldoctest

test/test_predictive_control.jl

@@ -24,6 +24,9 @@ sys = [ tf(1.90,[18.0,1])   tf(1.90,[18.0,1])   tf(1.90,[18.0,1]);
     kf = KalmanFilter(model)
     mpc8 = LinMPC(kf)
     @test isa(mpc8.estim, KalmanFilter)
+    mpc9 = LinMPC(model, nint_u=[1, 1], nint_ym=[0, 0])
+    @test mpc9.estim.nint_u  == [1, 1]
+    @test mpc9.estim.nint_ym == [0, 0]
 
     @test_throws ErrorException LinMPC(model, Hp=0)
     @test_throws ErrorException LinMPC(model, Hc=0)
@@ -131,6 +134,9 @@ end
     kf = KalmanFilter(model)
     mpc8 = ExplicitMPC(kf)
     @test isa(mpc8.estim, KalmanFilter)
+    mpc9 = ExplicitMPC(model, nint_u=[1, 1], nint_ym=[0, 0])
+    @test mpc9.estim.nint_u  == [1, 1]
+    @test mpc9.estim.nint_ym == [0, 0]
 
     @test_throws ErrorException ExplicitMPC(model, Hp=0)
     @test_throws ErrorException ExplicitMPC(model, Hc=0)
@@ -240,6 +246,12 @@ end
     im = InternalModel(nonlinmodel)
     nmpc9 = NonLinMPC(im)
     @test isa(nmpc9.estim, InternalModel)
+    nmpc10 = NonLinMPC(linmodel1, nint_u=[1, 1], nint_ym=[0, 0])
+    @test nmpc10.estim.nint_u  == [1, 1]
+    @test nmpc10.estim.nint_ym == [0, 0]
+    nmpc11 = NonLinMPC(nonlinmodel, nint_u=[1, 1], nint_ym=[0, 0])
+    @test nmpc11.estim.nint_u  == [1, 1]
+    @test nmpc11.estim.nint_ym == [0, 0]
 end
 
 @testset "NonLinMPC constraints" begin