changed: hold order nh renamed to h

Author: franckgaga

src/controller/transcription.jl

@@ -64,16 +64,16 @@ for this transcription method.
 struct MultipleShooting <: ShootingMethod end
 
 @doc raw"""
-    TrapezoidalCollocation(nh::Int=0)
+    TrapezoidalCollocation(h::Int=0)
 
-Construct an implicit trapezoidal [`TranscriptionMethod`](@ref) with `nh`th order hold.
+Construct an implicit trapezoidal [`TranscriptionMethod`](@ref) with `h`th order hold.
 
 This is the simplest collocation method. It supports continuous-time [`NonLinModel`](@ref)s
 only. The decision variables are the same as for [`MultipleShooting`](@ref), hence similar
-computational costs. The `nh` argument is `0` or `1`, for piecewise constant or linear
-manipulated inputs ``\mathbf{u}`` (`nh=1` is slightly less expensive). Note that the various
-[`DiffSolver`](@ref) assume zero-order hold, so `nh=1` will induce a mismatch if the plant
-is simulated using these solvers.
+computational costs. The `h` argument is `0` or `1`, for piecewise constant or linear
+manipulated inputs ``\mathbf{u}`` (`h=1` is slightly less expensive). Note that the various
+[`DiffSolver`](@ref) here assume zero-order hold, so `h=1` will induce a plant-model 
+mismatch if the plant is simulated with these solvers.
 
 This transcription computes the predictions by calling the continuous-time model in the
 equality constraint function and by using the implicit trapezoidal rule. It can handle
@@ -94,14 +94,14 @@ transcription method.
     for more details.
 """
 struct TrapezoidalCollocation <: CollocationMethod
-    nh::Int
+    h::Int
     nc::Int
-    function TrapezoidalCollocation(nh::Int=0)
-        if !(nh == 0 || nh == 1)
-            throw(ArgumentError("nh argument must be 0 or 1 for TrapezoidalCollocation."))
+    function TrapezoidalCollocation(h::Int=0)
+        if !(h == 0 || h == 1)
+            throw(ArgumentError("h argument must be 0 or 1 for TrapezoidalCollocation."))
         end
         nc = 2 # 2 collocation points per interval for trapezoidal rule
-        return new(nh, nc)
+        return new(h, nc)
     end
 end
 
@@ -1382,11 +1382,11 @@ extracted from the decision variables `Z̃`. The ``\mathbf{k}`` coefficients are
 evaluated from the continuous-time function `model.f!` and:
 ```math
 \begin{aligned}
-\mathbf{k}_1 &= \mathbf{f}\Big(\mathbf{x_0}(k),   \mathbf{û_0}(k), \mathbf{d_0}(k)  \Big) \\
-\mathbf{k}_2 &= \mathbf{f}\Big(\mathbf{x_0}(k+1), \mathbf{û_0}(k), \mathbf{d_0}(k+1)\Big) 
+\mathbf{k}_1 &= \mathbf{f}\Big(\mathbf{x_0}(k),   \mathbf{û_0}(k),   \mathbf{d_0}(k)  \Big) \\
+\mathbf{k}_2 &= \mathbf{f}\Big(\mathbf{x_0}(k+1), \mathbf{û_0}(k+h), \mathbf{d_0}(k+1)\Big) 
 \end{aligned}
 ```
-and the input of the augmented model is:
+in which ``h`` is the hold order `transcription.h` and the disturbed input is:
 ```math
 \mathbf{û_0}(k) = \mathbf{u_0}(k) + \mathbf{C_{s_u} x_s}(k)
 ``` 
@@ -1397,7 +1397,7 @@ function con_nonlinprogeq!(
     mpc::PredictiveController, model::NonLinModel, transcription::TrapezoidalCollocation, 
     U0, Z̃
 )
-    nu, nx̂, nd, nx, nh = model.nu, mpc.estim.nx̂, model.nd, model.nx, transcription.nh
+    nu, nx̂, nd, nx, h = model.nu, mpc.estim.nx̂, model.nd, model.nx, transcription.h
     Hp, Hc = mpc.Hp, mpc.Hc
     nΔU, nX̂ = nu*Hc, nx̂*Hp
     Ts, p = model.Ts, model.p
@@ -1407,7 +1407,7 @@ function con_nonlinprogeq!(
     X̂0_Z̃ = @views Z̃[(nΔU+1):(nΔU+nX̂)]
     x̂0 = @views mpc.estim.x̂0[1:nx̂]
     d0 = @views mpc.d0[1:nd]
-    if !iszero(nh)
+    if !iszero(h)
         k1, u0, û0 = @views K0[1:nx], U0[1:nu], Û0[1:nu]
         x0, xs     = @views x̂0[1:nx], x̂0[nx+1:end]
         mul!(û0, Cs_u, xs)                 
@@ -1431,7 +1431,7 @@ function con_nonlinprogeq!(
         mul!(xsnext, As, xs)
         ssnext .= @. xsnext - xsnext_Z̃
         # ----------------- deterministic defects --------------------------------------
-        if iszero(nh) # piecewise constant manipulated inputs u:
+        if iszero(h) # piecewise constant manipulated inputs u:
             u0 = @views U0[(1 + nu*(j-1)):(nu*j)]
             û0 = @views Û0[(1 + nu*(j-1)):(nu*j)]
             mul!(û0, Cs_u, xs)                 # ys_u(k) = Cs_u*xs(k)
@@ -1452,7 +1452,7 @@ function con_nonlinprogeq!(
         x̂0 = x̂0next_Z̃ # using states in Z̃ for next iteration (allow parallel for)
         d0 = d0next
     end
-    if !iszero(nh)
+    if !iszero(h)
         # j = Hp special case: u(k+Hp-1) = u(k+Hp) since Hc ≤ Hp implies Δu(k+Hp)=0
         x̂0, x̂0next_Z̃   = @views X̂0_Z̃[end-2nx̂+1:end-nx̂], X̂0_Z̃[end-nx̂+1:end]
         k1, k2         = @views K0[end-2nx+1:end-nx], K0[end-nx+1:end] # k1 already filled