franckgaga · Oct 16, 2026 · Oct 3, 2026 · Oct 5, 2026 · Oct 5, 2026 · Oct 8, 2026
diff --git a/Project.toml b/Project.toml
@@ -1,6 +1,6 @@
 name = "ModelPredictiveControl"
 uuid = "61f9bdb8-6ae4-484a-811f-bbf86720c31c"
-version = "2.14.4"
+version = "2.15.0"
 authors = ["Francis Gagnon"]
 
 [deps]

diff --git a/docs/src/internals/misc.md b/docs/src/internals/misc.md
@@ -24,3 +24,10 @@ ModelPredictiveControl.initpred!
 ModelPredictiveControl.linconstraint!
 ModelPredictiveControl.linconstrainteq!
 ```
+
+## Warm-starting
+
+```@docs
+ModelPredictiveControl.reset_warmstart!
+ModelPredictiveControl.set_warmstart!
+```
diff --git a/docs/src/internals/predictive_control.md b/docs/src/internals/predictive_control.md
@@ -34,7 +34,6 @@ ModelPredictiveControl.get_nonlincon_oracle(::NonLinMPC, ::ModelPredictiveContro
 
 ```@docs
 ModelPredictiveControl.optim_objective!(::PredictiveController)
-ModelPredictiveControl.set_warmstart_mpc!
 ModelPredictiveControl.predict!
 ModelPredictiveControl.con_nonlinprog!
 ModelPredictiveControl.con_nonlinprogeq!

diff --git a/docs/src/internals/state_estim.md b/docs/src/internals/state_estim.md
@@ -105,7 +105,6 @@ ModelPredictiveControl.update_estimate!
 
 ```@docs
 ModelPredictiveControl.optim_objective!(::MovingHorizonEstimator)
-ModelPredictiveControl.set_warmstart_mhe!
 ModelPredictiveControl.disturbedinput!
 ModelPredictiveControl.predict_mhe!
 ModelPredictiveControl.con_nonlinprog_mhe!

diff --git a/src/controller/construct.jl b/src/controller/construct.jl
@@ -94,15 +94,15 @@ end
 
 "Outer constructor to validate and convert weight matrices if necessary."
 function ControllerWeights(
-    model::SimModelODE{NT}, Hp, Hc, M_Hp, N_Hc, L_Hp, Cwt=Inf, Ewt=0
+    model::SimModel{NT}, Hp, Hc, M_Hp, N_Hc, L_Hp, Cwt=Inf, Ewt=0
 ) where {NT<:Real}
     validate_weights(model, Hp, Hc, M_Hp, N_Hc, L_Hp, Cwt, Ewt)
     M_Hp, N_Hc, L_Hp = NT.(M_Hp), NT.(N_Hc), NT.(L_Hp)
     return ControllerWeights{NT}(M_Hp, N_Hc, L_Hp, Cwt, Ewt)
 end
 
 "Validate predictive controller weight and horizon specified values."
-function validate_weights(model, Hp, Hc, M_Hp, N_Hc, L_Hp, C=Inf, E=nothing)
+function validate_weights(model::SimModel, Hp, Hc, M_Hp, N_Hc, L_Hp, C=Inf, E=nothing)
     nu, ny = model.nu, model.ny
     nM, nN, nL = ny*Hp, nu*Hc, nu*Hp
     Hp < 1 && throw(ArgumentError("Prediction horizon Hp should be ≥ 1"))

diff --git a/src/controller/execute.jl b/src/controller/execute.jl
@@ -7,8 +7,8 @@ It also stores `u - mpc.estim.model.uop` at `mpc.lastu0` for converting the inpu
 ``\mathbf{ΔU}`` to inputs ``\mathbf{U}``.
 """
 function initstate!(mpc::PredictiveController, u, ym, d=mpc.estim.buffer.empty)
-    mpc.Z̃ .= 0
     mpc.lastu0 .= u .- mpc.estim.model.uop
+    reset_warmstart!(mpc, mpc.transcription)
     return initstate!(mpc.estim, u, ym, d)
 end
 
@@ -144,14 +144,15 @@ julia> round.(getinfo(mpc)[:Ŷ], digits=3)
 """
 function getinfo(mpc::PredictiveController{NT}) where NT<:Real
     model, buffer, transcription = mpc.estim.model, mpc.buffer, mpc.transcription
-    nΔŨ, nK = mpc.Hc*model.nu + mpc.nϵ, mpc.Hp*model.nk̄
+    nk̄ = get_nk̄(model, transcription)
+    nΔŨ, nK̄ = mpc.Hc*model.nu + mpc.nϵ, mpc.Hp*nk̄
     nŶe, nUe = (mpc.Hp+1)*model.ny, (mpc.Hp+1)*model.nu
     nX̂0, nÛ0 = mpc.estim.nx̂*mpc.Hp, model.nu*mpc.Hp 
     Z̃ = mpc.Z̃
     info = Dict{Symbol, Any}()
     ΔŨ     = Vector{NT}(undef, nΔŨ)
     x̂0end  = similar(mpc.estim.x̂0)
-    K      = Vector{NT}(undef, nK) 
+    K      = Vector{NT}(undef, nK̄) 
     Ue, Ŷe = Vector{NT}(undef, nUe), Vector{NT}(undef, nŶe)
     U0, Ŷ0 = similar(mpc.Uop), similar(mpc.Yop)
     Û0, X̂0 = Vector{NT}(undef, nÛ0), Vector{NT}(undef, nX̂0)
@@ -277,25 +278,25 @@ function initpred!(mpc::PredictiveController, model::LinModel, ry, d, lastu, D̂
 end
 
 @doc raw"""
-    initpred!(mpc::PredictiveController, model::SimModelODE, ry, d, lastu, D̂, R̂y, R̂u) -> nothing
+    initpred!(mpc::PredictiveController, model::SimModel, ry, d, lastu, D̂, R̂y, R̂u) -> nothing
 
 Init `lastu0, ŷ, F, d0, D̂0, D̂e, R̂y, R̂u` vectors when model is not a [`LinModel`](@ref).
 """
-function initpred!(mpc::PredictiveController, model::SimModelODE, ry, d, lastu, D̂, R̂y, R̂u)
+function initpred!(mpc::PredictiveController, model::SimModel, ry, d, lastu, D̂, R̂y, R̂u)
     initpred_common!(mpc, model, ry, d, lastu, D̂, R̂y, R̂u)
     return nothing
 end
 
 """
-    initpred_common!(mpc::PredictiveController, model::SimModelODE, ry, d, lastu, D̂, R̂y, R̂u) -> F
+    initpred_common!(mpc::PredictiveController, model::SimModel, ry, d, lastu, D̂, R̂y, R̂u) -> F
 
-Common computations of `initpred!` for all types of [`SimModelODE`](@ref).
+Common computations of `initpred!` for all types of [`SimModel`](@ref).
 
 Will also init `mpc.F` with 0 values, or with the stochastic predictions `Ŷs` if `mpc.estim`
 is an [`InternalModel`](@ref). The function returns `mpc.F`.
 """
 function initpred_common!(
-    mpc::PredictiveController, model::SimModelODE, ry, d, lastu, D̂, R̂y, R̂u
+    mpc::PredictiveController, model::SimModel, ry, d, lastu, D̂, R̂y, R̂u
 )
     mpc.lastu0 .= lastu .- model.uop
     mul!(mpc.Tu_lastu0, mpc.Tu, mpc.lastu0)
@@ -327,14 +328,14 @@ end
 predictstoch!(Ŷs, ::PredictiveController, ::StateEstimator) = (Ŷs .= 0; nothing)
 
 @doc raw"""
-    linconstraint_custom!(mpc::PredictiveController, model::SimModelODE)
+    linconstraint_custom!(mpc::PredictiveController, model::SimModel)
 
 Init the ``\mathbf{F_w}`` vector for the custom linear inequality constraints.
 
 See [`relaxW`](@ref) for the definition of the vector. The function does nothing if
 `mpc.con.nw < 1`.
 """
-function linconstraint_custom!(mpc::PredictiveController, model::SimModelODE)
+function linconstraint_custom!(mpc::PredictiveController, model::SimModel)
     mpc.con.nw < 1 && return nothing
     ny, nu, nd, buffer = model.ny, model.nu, model.nd, mpc.buffer
     Fw = mpc.con.Fw
@@ -458,15 +459,15 @@ end
 
 Optimize the objective function of `mpc` [`PredictiveController`](@ref) and return the solution `Z̃`.
 
-If first warm-starts the solver with [`set_warmstart_mpc!`](@ref). It then calls 
+If first warm-starts the solver with [`set_warmstart!`](@ref). It then calls 
 `JuMP.optimize!(mpc.optim)` and extract the solution. A failed optimization prints an 
 `@error` log in the REPL and returns the warm-start value. A failed optimization also prints
 [`getinfo`](@ref) results in the debug log [if activated](https://docs.julialang.org/en/v1/stdlib/Logging/#Example:-Enable-debug-level-messages).
 """
 function optim_objective!(mpc::PredictiveController{NT}) where {NT<:Real}
     model, optim = mpc.estim.model, mpc.optim
     Z̃var::Vector{JuMP.VariableRef} = optim[:Z̃var]
-    Z̃s = set_warmstart_mpc!(mpc, mpc.transcription, Z̃var)
+    Z̃s = set_warmstart!(mpc, mpc.transcription, Z̃var)
     set_force∇!(mpc)
     set_objective_linear_coef!(mpc, model, Z̃var)
     try
@@ -509,7 +510,7 @@ end
 set_force∇!(::PredictiveController) = nothing
 
 "By default, no need to update the objective function."
-set_objective_linear_coef!(::PredictiveController, ::SimModelODE, _) = nothing
+set_objective_linear_coef!(::PredictiveController, ::SimModel, _) = nothing
 
 "Update the linear coefficients of the quadratic objective with `mpc.q̃` for `LinModel`."
 function set_objective_linear_coef!(mpc::PredictiveController, ::LinModel, Z̃var)

diff --git a/src/controller/linmpc.jl b/src/controller/linmpc.jl
@@ -104,6 +104,7 @@ struct LinMPC{
             Uop, Yop, Dop,
             buffer
         )
+        reset_warmstart!(mpc, transcription)
         init_optimization!(mpc, model, optim)
         return mpc
     end

diff --git a/src/controller/nonlinmpc.jl b/src/controller/nonlinmpc.jl
@@ -147,15 +147,16 @@ struct NonLinMPC{
             Uop, Yop, Dop,
             buffer
         )
+        reset_warmstart!(mpc, transcription)
         init_optimization!(mpc, model, optim)
         return mpc
     end
 end
 
 @doc raw"""
-    NonLinMPC(model::SimModelODE; <keyword arguments>)
+    NonLinMPC(model::SimModel; <keyword arguments>)
 
-Construct a nonlinear predictive controller based on [`SimModelODE`](@ref) `model`.
+Construct a nonlinear predictive controller based on [`SimModel`](@ref) `model`.
 
 Both [`NonLinModel`](@ref) and [`LinModel`](@ref) are supported (see Extended Help). The 
 controller minimizes the following objective function at each discrete time ``k``:
@@ -196,7 +197,8 @@ definition of the other variables.
 This method uses the default state estimator:
 
 - if `model` is a [`LinModel`](@ref), a [`SteadyKalmanFilter`](@ref) with default arguments;
-- else, an [`UnscentedKalmanFilter`](@ref) with default arguments. 
+- if `model` is a [`NonLinModel`](@ref), an [`UnscentedKalmanFilter`](@ref) with default arguments;
+- else, a [`MovingHorizonEstimator`](@ref) with default arguments.
 
 This controller allocates memory at each time step for the optimization.
 
@@ -205,7 +207,7 @@ This controller allocates memory at each time step for the optimization.
     `MethodError: no method matching Float64(::ForwardDiff.Dual)`.
 
 # Arguments
-- `model::SimModelODE` : model used for controller predictions and state estimations.
+- `model::SimModel` : model used for controller predictions and state estimations.
 - `Hp::Int=10+nk` : prediction horizon ``H_p``, `nk` is the number of delays if `model` is a
    [`LinModel`](@ref) (must be specified otherwise).
 - `Hc::Union{Int, Vector{Int}}=2` : control horizon ``H_c``, custom move blocking pattern is 
@@ -229,7 +231,8 @@ This controller allocates memory at each time step for the optimization.
    Extended Help).
 - `nc=0` : number of custom nonlinear inequality constraints.
 - `p=model.p` : ``J_E`` and ``\mathbf{g_c}`` functions parameter ``\mathbf{p}`` (any type).
-- `transcription=SingleShooting()` : a [`TranscriptionMethod`](@ref) for the optimization.
+- `transcription=default_transcription(model)` : a [`TranscriptionMethod`](@ref) object,
+   default to [`SingleShooting`](@ref) or `model.transcription` for [`NonLinModelDAE`](@ref).
 - `optim=JuMP.Model(Ipopt.Optimizer)` : nonlinear optimizer used in the predictive
    controller, provided as a [`JuMP.Model`](@extref) object (default to [`Ipopt`](https://github.com/jump-dev/Ipopt.jl) optimizer).
 - `gradient=AutoForwardDiff()` : an `AbstractADType` backend for the gradient of the objective
@@ -344,7 +347,7 @@ NonLinMPC controller with a sample time Ts = 5.0 s:
     `10/Cwt` (if not already set), to scale the small values of ``ϵ``.
 """
 function NonLinMPC(
-    model::SimModelODE;
+    model::SimModel;
     Hp::Int = default_Hp(model),
     Hc::IntVectorOrInt = DEFAULT_HC,
     Mwt  = fill(DEFAULT_MWT, model.ny),
@@ -364,7 +367,7 @@ function NonLinMPC(
     gc ::Function = gc!,
     nc::Int = 0,
     p = model.p,
-    transcription::TranscriptionMethod = SingleShooting(),
+    transcription::TranscriptionMethod = default_transcription(model),
     optim::JuMP.GenericModel = JuMP.Model(DEFAULT_NLP_OPTIMIZER, add_bridges=false),
     gradient::AbstractADType = DEFAULT_GRADIENT,
     jacobian::AbstractADType = default_jacobian(transcription),
@@ -437,7 +440,7 @@ function NonLinMPC(
     gc ::Function = gc!,
     nc = 0,
     p = estim.model.p,
-    transcription::TranscriptionMethod = SingleShooting(),
+    transcription::TranscriptionMethod = default_transcription(estim.model),
     optim::JuMP.GenericModel = JuMP.Model(DEFAULT_NLP_OPTIMIZER, add_bridges=false),
     gradient::AbstractADType = DEFAULT_GRADIENT,
     jacobian::AbstractADType = default_jacobian(transcription),
@@ -464,6 +467,7 @@ function NonLinMPC(
 end
 
 default_estimator(model::SimModelODE; kwargs...) = UnscentedKalmanFilter(model; kwargs...)
+default_estimator(model::SimModelDAE; kwargs...) = MovingHorizonEstimator(model; kwargs...)
 default_estimator(model::LinModel; kwargs...) = SteadyKalmanFilter(model; kwargs...)
 
 """
@@ -739,11 +743,11 @@ function addinfo!(info, mpc::NonLinMPC{NT}) where NT<:Real
 end
 
 """
-    init_optimization!(mpc::NonLinMPC, model::SimModelODE, optim::JuMP.GenericModel) -> nothing
+    init_optimization!(mpc::NonLinMPC, model::SimModel, optim::JuMP.GenericModel) -> nothing
 
 Init the nonlinear optimization for [`NonLinMPC`](@ref) controllers.
 """
-function init_optimization!(mpc::NonLinMPC, model::SimModelODE, optim::JuMP.GenericModel)  
+function init_optimization!(mpc::NonLinMPC, model::SimModel, optim::JuMP.GenericModel)  
     # --- variables and linear constraints ---
     con = mpc.con
     nZ̃ = length(mpc.Z̃)
@@ -844,8 +848,8 @@ function get_nonlinobj_op(mpc::NonLinMPC, optim::JuMP.GenericModel{JNT}) where J
     Û0::Vector{JNT}, X̂0::Vector{JNT} = zeros(JNT, nU),  zeros(JNT, nX̂)
     gc::Vector{JNT}, g::Vector{JNT}  = zeros(JNT, nc),  zeros(JNT, ng)
     geq::Vector{JNT}                 = zeros(JNT, neq)
-    function J!(Z̃, ΔŨ, x̂0end, Ue, Ŷe, U0, Ŷ0, Û0, K, X̂0, gc, g, geq)
-        update_predictions!(ΔŨ, x̂0end, Ue, Ŷe, U0, Ŷ0, Û0, K, X̂0, gc, g, geq, mpc, Z̃)
+    function J!(Z̃, ΔŨ, x̂0end, Ue, Ŷe, U0, Ŷ0, Û0, K̄, X̂0, gc, g, geq)
+        update_predictions!(ΔŨ, x̂0end, Ue, Ŷe, U0, Ŷ0, Û0, K̄, X̂0, gc, g, geq, mpc, Z̃)
         return obj_nonlinprog!(Ŷ0, U0, mpc, Ue, Ŷe, ΔŨ)
     end
     Z̃_J = zeros(JNT, nZ̃)
@@ -1124,7 +1128,8 @@ Update in-place all vectors for the predictions of `mpc` controller at decision
 The method mutates all the arguments before the `mpc` argument.
 """
 function update_predictions!(
-    ΔŨ, x̂0end, Ue, Ŷe, U0, Ŷ0, Û0, K̄, X̂0, gc, g, geq, mpc::PredictiveController, Z̃
+    ΔŨ, x̂0end, Ue, Ŷe, U0, Ŷ0, Û0, K̄, X̂0, gc, g, geq, 
+    mpc::PredictiveController, Z̃
 )
     model, transcription = mpc.estim.model, mpc.transcription
     U0 = getU0!(U0, mpc, Z̃)