doc: hide warning temp fix

Author: franckgaga

docs/src/manual/nonlinmpc.md

@@ -4,9 +4,9 @@
 Pages = ["nonlinmpc.md"]
 ```
 
-```@setup 1
-using Logging; errlogger = ConsoleLogger(stderr, Error);
-old_logger = global_logger(); global_logger(errlogger);
+```@setup man_nonlin
+using Logging; 
+with_logger(ConsoleLogger(stderr, Error)) do
 ```
 
 ## Nonlinear Model
@@ -45,7 +45,7 @@ the end of the pendulum in kg, all bundled in the parameter vector ``\mathbf{p}
 constructor assumes by default that the state function `f` is continuous in time, that is,
 an ordinary differential equation system (like here):
 
-```@example 1
+```@example man_nonlin
 using ModelPredictiveControl
 function f(x, u, _ , p)
     g, L, K, m = p          # [m/s²], [m], [kg/s], [kg]
@@ -69,7 +69,7 @@ vector of you want to modify it later. A 4th order [`RungeKutta`](@ref) method s
 differential equations by default. It is good practice to first simulate `model` using
 [`sim!`](@ref) as a quick sanity check:
 
-```@example 1
+```@example man_nonlin
 using Plots
 u = [0.5]
 N = 35
@@ -88,7 +88,7 @@ method.
 
 An [`UnscentedKalmanFilter`](@ref) estimates the plant state :
 
-```@example 1
+```@example man_nonlin
 α=0.01; σQ=[0.1, 1.0]; σR=[5.0]; nint_u=[1]; σQint_u=[0.1]
 estim = UnscentedKalmanFilter(model; α, σQ, σR, nint_u, σQint_u)
 ```
@@ -100,7 +100,7 @@ Also, the argument `nint_u` explicitly adds one integrating state at the model i
 motor torque ``τ``, with an associated standard deviation `σQint_u` of 0.1 N m. The
 estimator tuning is tested on a plant with a 25 % larger friction coefficient ``K``:
 
-```@example 1
+```@example man_nonlin
 p_plant = copy(p_model)
 p_plant[3] = 1.25*p_model[3]
 plant = setname!(NonLinModel(f, h, Ts, nu, nx, ny; p=p_plant); u=vu, x=vx, y=vy)
@@ -117,7 +117,7 @@ static errors. The Kalman filter performance seems sufficient for control.
 As the motor torque is limited to -1.5 to 1.5 N m, we incorporate the input constraints in
 a [`NonLinMPC`](@ref):
 
-```@example 1
+```@example man_nonlin
 Hp, Hc, Mwt, Nwt = 20, 2, [0.5], [2.5]
 nmpc = NonLinMPC(estim; Hp, Hc, Mwt, Nwt, Cwt=Inf)
 umin, umax = [-1.5], [+1.5]
@@ -127,7 +127,7 @@ nmpc = setconstraint!(nmpc; umin, umax)
 The option `Cwt=Inf` disables the slack variable `ϵ` for constraint softening. We test `mpc`
 performance on `plant` by imposing an angular setpoint of 180° (inverted position):
 
-```@example 1
+```@example man_nonlin
 using JuMP; unset_time_limit_sec(nmpc.optim) # hide
 res_ry = sim!(nmpc, N, [180.0], plant=plant, x_0=[0, 0], x̂_0=[0, 0, 0])
 plot(res_ry)
@@ -140,7 +140,7 @@ The controller seems robust enough to variations on ``K`` coefficient. Starting
 inverted position, the closed-loop response to a step disturbances of 10° is also
 satisfactory:
 
-```@example 1
+```@example man_nonlin
 res_yd = sim!(nmpc, N, [180.0], plant=plant, x_0=[π, 0], x̂_0=[π, 0, 0], y_step=[10])
 plot(res_yd)
 savefig("plot4_NonLinMPC.svg"); nothing # hide
@@ -181,7 +181,7 @@ angle ``θ`` is measured here). As the arguments of [`NonLinMPC`](@ref) economic
 `JE` do not include the states, the speed is now defined as an unmeasured output to design a
 Kalman Filter similar to the previous one (``\mathbf{y^m} = θ`` and ``\mathbf{y^u} = ω``):
 
-```@example 1
+```@example man_nonlin
 h2(x, _ , _ ) = [180/π*x[1], x[2]]
 nu, nx, ny = 1, 2, 2
 model2 = setname!(NonLinModel(f, h2, Ts, nu, nx, ny; p=p_model), u=vu, x=vx, y=[vy; vx[2]])
@@ -193,7 +193,7 @@ The `plant2` object based on `h2` is also required since [`sim!`](@ref) expects
 output vector of `plant` argument corresponds to the model output vector in `mpc` argument.
 We can now define the ``J_E`` function and the `empc` controller:
 
-```@example 1
+```@example man_nonlin
 function JE(Ue, Ŷe, _ , p)
     Ts = p
     τ, ω = Ue[1:end-1], Ŷe[2:2:end-1]
@@ -209,7 +209,7 @@ lead to a static error on the angle setpoint. The second element of `Mwt` is zer
 speed ``ω`` is not requested to track a setpoint. The closed-loop response to a 180°
 setpoint is similar:
 
-```@example 1
+```@example man_nonlin
 unset_time_limit_sec(empc.optim)    # hide
 res2_ry = sim!(empc, N, [180, 0], plant=plant2, x_0=[0, 0], x̂_0=[0, 0, 0])
 plot(res2_ry, ploty=[1])
@@ -220,7 +220,7 @@ savefig("plot5_NonLinMPC.svg"); nothing # hide
 
 and the energy consumption is slightly lower:
 
-```@example 1
+```@example man_nonlin
 function calcW(res)
     τ, ω = res.U_data[1, 1:end-1], res.X_data[2, 1:end-1]
     return Ts*sum(τ.*ω)
@@ -230,7 +230,7 @@ Dict(:W_nmpc => calcW(res_ry), :W_empc => calcW(res2_ry))
 
 Also, for a 10° step disturbance:
 
-```@example 1
+```@example man_nonlin
 res2_yd = sim!(empc, N, [180; 0]; plant=plant2, x_0=[π, 0], x̂_0=[π, 0, 0], y_step=[10, 0])
 plot(res2_yd, ploty=[1])
 savefig("plot6_NonLinMPC.svg"); nothing # hide
@@ -241,7 +241,7 @@ savefig("plot6_NonLinMPC.svg"); nothing # hide
 the new controller is able to recuperate a little more energy from the pendulum (i.e.
 negative work):
 
-```@example 1
+```@example man_nonlin
 Dict(:W_nmpc => calcW(res_yd), :W_empc => calcW(res2_yd))
 ```
 
@@ -268,7 +268,7 @@ in which ``ϵ`` is the slack variable (scalar), an necessary feature to ensure f
 when the nonlinear inequality constraints are active. There is also an additional `LHS`
 argument ("left-hand side" of the inequality above) for the in-place version:
 
-```@example 1
+```@example man_nonlin
 function gc!(LHS, Ue, Ŷe, _, p, ϵ)
     Pmax, Hp = p
     i_τ, i_ω = 1, 2
@@ -290,7 +290,7 @@ similar mutating forms are also possible for the `f` and `h` functions of [`NonL
 We construct the controller by enabling relaxation with the `Cwt` argument, and also by
 specifying the number of custom inequality constraints `nc`:
 
-```@example 1
+```@example man_nonlin
 Cwt, Pmax, nc = 1e5, 3, Hp+1
 p_nmpc2 = [Pmax, Hp]
 nmpc2 = NonLinMPC(estim2; Hp, Hc, Nwt=Nwt, Mwt=[0.5, 0], Cwt, gc!, nc, p=p_nmpc2)
@@ -300,14 +300,14 @@ nmpc2 # hide
 
 In addition to the 180° setpoint response:
 
-```@example 1
-res3_ry = sim!(nmpc2, N, [180; 0]; plant=plant2, x_0=[0, 0], x̂_0=[0, 0, 0])
+```@example man_nonlin
+res3_ry = sim!(nmpc2, N, [180; 0]; plant=plant2, x_0=[0, 0], x̂_0=[0, 0, 0]);
 nothing # hide
 ```
 
 a plot for the power ``P(t)`` is included below:
 
-```@example 1
+```@example man_nonlin
 function plotWithPower(res, Pmax)
     t, τ, ω = res.T_data, res.U_data[1, :], res.X_data[2, :]
     P, Pmax = τ.*ω, fill(Pmax, size(t))
@@ -334,13 +334,13 @@ fast dynamics. To ease the design and comparison with [`LinMPC`](@ref), the [`li
 function allows automatic linearization of [`NonLinModel`](@ref) based on [`ForwardDiff.jl`](https://juliadiff.org/ForwardDiff.jl/stable/).
 We first linearize `model` at the point ``θ = π`` rad and ``ω = τ = 0`` (inverted position):
 
-```@example 1
+```@example man_nonlin
 linmodel = linearize(model, x=[π, 0], u=[0])
 ```
 
 A [`SteadyKalmanFilter`](@ref) and a [`LinMPC`](@ref) are designed from `linmodel`:
 
-```@example 1
+```@example man_nonlin
 
 skf = SteadyKalmanFilter(linmodel; σQ, σR, nint_u, σQint_u)
 mpc = LinMPC(skf; Hp, Hc, Mwt, Nwt, Cwt=Inf)
@@ -349,7 +349,7 @@ mpc = setconstraint!(mpc, umin=[-1.5], umax=[+1.5])
 
 The linear controller satisfactorily rejects the 10° step disturbance:
 
-```@example 1
+```@example man_nonlin
 res_lin = sim!(mpc, N, [180.0]; plant, x_0=[π, 0], y_step=[10])
 plot(res_lin)
 savefig("plot9_NonLinMPC.svg"); nothing # hide
@@ -367,7 +367,7 @@ than one):
     embedded quadratic programming using recursive LDLᵀ updates. IEEE Trans. Autom. Contr.,
     67(8). <https://doi.org/doi:10.1109/TAC.2022.3176430>.
 
-```@example 1
+```@example man_nonlin
 using LinearAlgebra; poles = eigvals(linmodel.A)
 ```
 
@@ -379,7 +379,7 @@ using Pkg; Pkg.add("DAQP")
 
 Constructing a [`LinMPC`](@ref) with `DAQP`:
 
-```@example 1
+```@example man_nonlin
 using JuMP, DAQP
 daqp = Model(DAQP.Optimizer, add_bridges=false)
 mpc2 = LinMPC(skf; Hp, Hc, Mwt, Nwt, Cwt=Inf, optim=daqp)
@@ -388,7 +388,7 @@ mpc2 = setconstraint!(mpc2; umin, umax)
 
 does slightly improve the rejection of the step disturbance:
 
-```@example 1
+```@example man_nonlin
 res_lin2 = sim!(mpc2, N, [180.0]; plant, x_0=[π, 0], y_step=[10])
 plot(res_lin2)
 savefig("plot10_NonLinMPC.svg"); nothing # hide
@@ -402,7 +402,7 @@ average). However, remember that `linmodel` is only valid for angular positions
 For example, the 180° setpoint response from 0° is unsatisfactory since the predictions are
 poor in the first quadrant:
 
-```@example 1
+```@example man_nonlin
 res_lin3 = sim!(mpc2, N, [180.0]; plant, x_0=[0, 0])
 plot(res_lin3)
 savefig("plot11_NonLinMPC.svg"); nothing # hide
@@ -422,7 +422,7 @@ be designed with minimal efforts. The [`SteadyKalmanFilter`](@ref) does not supp
 [`setmodel!`](@ref) so we need to use the time-varying [`KalmanFilter`](@ref), and we
 initialize it with a linearization at ``θ = ω = τ = 0``:
 
-```@example 1
+```@example man_nonlin
 linmodel = linearize(model, x=[0, 0], u=[0])
 kf = KalmanFilter(linmodel; σQ, σR, nint_u, σQint_u)
 mpc3 = LinMPC(kf; Hp, Hc, Mwt, Nwt, Cwt=Inf, optim=daqp)
@@ -431,7 +431,7 @@ mpc3 = setconstraint!(mpc3; umin, umax)
 
 We create a function that simulates the plant and the adaptive controller:
 
-```@example 1
+```@example man_nonlin
 function sim_adapt!(mpc, nonlinmodel, N, ry, plant, x_0, x̂_0, y_step=[0])
     U_data, Y_data, Ry_data = zeros(plant.nu, N), zeros(plant.ny, N), zeros(plant.ny, N)
     setstate!(plant, x_0)
@@ -459,7 +459,7 @@ that is, when both ``\mathbf{u}(k)`` and ``\mathbf{x̂}_{k}(k)`` are available a
 operating point. The [`SimResult`](@ref) object is for plotting purposes only. The adaptive
 [`LinMPC`](@ref) performances are similar to the nonlinear MPC, both for the 180° setpoint:
 
-```@example 1
+```@example man_nonlin
 x_0 = [0, 0]; x̂_0 = [0, 0, 0]; ry = [180]
 res_slin = sim_adapt!(mpc3, model, N, ry, plant, x_0, x̂_0)
 plot(res_slin)
@@ -470,7 +470,7 @@ savefig("plot12_NonLinMPC.svg"); nothing # hide
 
 and the 10° step disturbance:
 
-```@example 1
+```@example man_nonlin
 x_0 = [π, 0]; x̂_0 = [π, 0, 0]; y_step = [10]
 res_slin = sim_adapt!(mpc3, model, N, ry, plant, x_0, x̂_0, y_step)
 plot(res_slin)
@@ -482,6 +482,6 @@ savefig("plot13_NonLinMPC.svg"); nothing # hide
 The computations of the successive linearization MPC are about 75 times faster than the
 nonlinear MPC on average, an impressive gain for similar closed-loop performances!
 
-```@setup 1
-global_logger(old_logger);
+```@setup man_nonlin
+end
 ```