changed: conversion matrices with lower case 'u' for readability

Author: franckgaga

src/controller/construct.jl

@@ -5,7 +5,7 @@ struct PredictiveControllerBuffer{NT<:Real}
     Ŷ ::Vector{NT}
     U ::Vector{NT}
     Ẽ ::Matrix{NT}
-    P̃U::Matrix{NT}
+    P̃u::Matrix{NT}
     empty::Vector{NT}
 end
 
@@ -27,9 +27,9 @@ function PredictiveControllerBuffer(
     Ŷ  = Vector{NT}(undef, ny*Hp)
     U  = Vector{NT}(undef, nu*Hp)
     Ẽ  = Matrix{NT}(undef, ny*Hp, nZ̃)
-    P̃U = Matrix{NT}(undef, nu*Hp, nZ̃)
+    P̃u = Matrix{NT}(undef, nu*Hp, nZ̃)
     empty = Vector{NT}(undef, 0)
-    return PredictiveControllerBuffer{NT}(u, Z̃, D̂, Ŷ, U, Ẽ, P̃U, empty)
+    return PredictiveControllerBuffer{NT}(u, Z̃, D̂, Ŷ, U, Ẽ, P̃u, empty)
 end
 
 "Include all the objective function weights of [`PredictiveController`](@ref)"
@@ -526,7 +526,7 @@ function validate_args(mpc::PredictiveController, ry, d, D̂, R̂y, R̂u)
 end
 
 @doc raw"""
-    init_quadprog(model::LinModel, weights::ControllerWeights, Ẽ, P̃ΔU, P̃U) -> H̃
+    init_quadprog(model::LinModel, weights::ControllerWeights, Ẽ, P̃Δu, P̃u) -> H̃
 
 Init the quadratic programming Hessian `H̃` for MPC.
 
@@ -537,16 +537,16 @@ The matrix appear in the quadratic general form:
 The Hessian matrix is constant if the model and weights are linear and time invariant (LTI): 
 ```math
     \mathbf{H̃} = 2 (   \mathbf{Ẽ}'      \mathbf{M}_{H_p} \mathbf{Ẽ} 
-                     + \mathbf{P̃_{ΔU}}' \mathbf{Ñ}_{H_c} \mathbf{P̃_{ΔU}} 
-                     + \mathbf{P̃_{U}}'  \mathbf{L}_{H_p} \mathbf{P̃_{U}}     )
+                     + \mathbf{P̃_{Δu}}' \mathbf{Ñ}_{H_c} \mathbf{P̃_{Δu}} 
+                     + \mathbf{P̃_{u}}'  \mathbf{L}_{H_p} \mathbf{P̃_{u}}     )
 ```
 The vector ``\mathbf{q̃}`` and scalar ``r`` need recalculation each control period ``k``, see
 [`initpred!`](@ref). ``r`` does not impact the minima position. It is thus useless at
 optimization but required to evaluate the minimal ``J`` value.
 """
-function init_quadprog(::LinModel, weights::ControllerWeights, Ẽ, P̃ΔU, P̃U)
+function init_quadprog(::LinModel, weights::ControllerWeights, Ẽ, P̃Δu, P̃u)
     M_Hp, Ñ_Hc, L_Hp = weights.M_Hp, weights.Ñ_Hc, weights.L_Hp
-    H̃ = Hermitian(2*(Ẽ'*M_Hp*Ẽ + P̃ΔU'*Ñ_Hc*P̃ΔU + P̃U'*L_Hp*P̃U), :L)
+    H̃ = Hermitian(2*(Ẽ'*M_Hp*Ẽ + P̃Δu'*Ñ_Hc*P̃Δu + P̃u'*L_Hp*P̃u), :L)
     return H̃
 end
 "Return empty matrix if `model` is not a [`LinModel`](@ref)."
@@ -559,20 +559,20 @@ end
     init_defaultcon_mpc(
         estim::StateEstimator, transcription::TranscriptionMethod,
         Hp, Hc, C, 
-        PΔU, PU, E, 
+        PΔu, Pu, E, 
         ex̂, fx̂, gx̂, jx̂, kx̂, vx̂, bx̂, 
         Eŝ, Fŝ, Gŝ, Jŝ, Kŝ, Vŝ, Bŝ,
         gc!=nothing, nc=0
-    ) -> con, nϵ, P̃ΔU, P̃U, Ẽ, Ẽŝ
+    ) -> con, nϵ, P̃Δu, P̃u, Ẽ, Ẽŝ
 
 Init `ControllerConstraint` struct with default parameters based on estimator `estim`.
 
-Also return `P̃ΔU`, `P̃U`, `Ẽ` and `Ẽŝ` matrices for the the augmented decision vector `Z̃`.
+Also return `P̃Δu`, `P̃u`, `Ẽ` and `Ẽŝ` matrices for the the augmented decision vector `Z̃`.
 """
 function init_defaultcon_mpc(
     estim::StateEstimator{NT}, transcription::TranscriptionMethod,
     Hp,  Hc, C, 
-    PΔU, PU, E, 
+    PΔu, Pu, E, 
     ex̂, fx̂, gx̂, jx̂, kx̂, vx̂, bx̂, 
     Eŝ, Fŝ, Gŝ, Jŝ, Kŝ, Vŝ, Bŝ,
     gc!::GCfunc = nothing, nc = 0
@@ -592,8 +592,8 @@ function init_defaultcon_mpc(
         repeat_constraints(Hp, Hc, u0min, u0max, Δumin, Δumax, y0min, y0max)
     C_umin, C_umax, C_Δumin, C_Δumax, C_ymin, C_ymax = 
         repeat_constraints(Hp, Hc, c_umin, c_umax, c_Δumin, c_Δumax, c_ymin, c_ymax)
-    A_Umin,  A_Umax, P̃U  = relaxU(PU, C_umin, C_umax, nϵ)
-    A_ΔŨmin, A_ΔŨmax, ΔŨmin, ΔŨmax, P̃ΔU = relaxΔU(PΔU, C_Δumin, C_Δumax, ΔUmin, ΔUmax, nϵ)
+    A_Umin,  A_Umax, P̃u  = relaxU(Pu, C_umin, C_umax, nϵ)
+    A_ΔŨmin, A_ΔŨmax, ΔŨmin, ΔŨmax, P̃Δu = relaxΔU(PΔu, C_Δumin, C_Δumax, ΔUmin, ΔUmax, nϵ)
     A_Ymin,  A_Ymax, Ẽ  = relaxŶ(E, C_ymin, C_ymax, nϵ)
     A_x̂min,  A_x̂max, ẽx̂ = relaxterminal(ex̂, c_x̂min, c_x̂max, nϵ)
     A_ŝ, Ẽŝ = augmentdefect(Eŝ, nϵ)
@@ -620,7 +620,7 @@ function init_defaultcon_mpc(
         C_ymin  , C_ymax , c_x̂min , c_x̂max , i_g,
         gc!     , nc
     )
-    return con, nϵ, P̃ΔU, P̃U, Ẽ, Ẽŝ
+    return con, nϵ, P̃Δu, P̃u, Ẽ, Ẽŝ
 end
 
 "Repeat predictive controller constraints over prediction `Hp` and control `Hc` horizons."
@@ -635,13 +635,13 @@ function repeat_constraints(Hp, Hc, umin, umax, Δumin, Δumax, ymin, ymax)
 end
 
 @doc raw"""
-    relaxU(PU, C_umin, C_umax, nϵ) -> A_Umin, A_Umax, P̃U
+    relaxU(Pu, C_umin, C_umax, nϵ) -> A_Umin, A_Umax, P̃u
 
 Augment manipulated inputs constraints with slack variable ϵ for softening.
 
 Denoting the decision variables augmented with the slack variable
 ``\mathbf{Z̃} = [\begin{smallmatrix} \mathbf{Z} \\ ϵ \end{smallmatrix}]``, it returns the
-augmented conversion matrix ``\mathbf{P̃U}``, similar to the one described at
+augmented conversion matrix ``\mathbf{P̃u}``, similar to the one described at
 [`init_ZtoU`](@ref). It also returns the ``\mathbf{A}`` matrices for the inequality
 constraints:
 ```math
@@ -650,36 +650,36 @@ constraints:
     \mathbf{A_{U_{max}}} 
 \end{bmatrix} \mathbf{Z̃} ≤
 \begin{bmatrix}
-    - \mathbf{U_{min} + T_U u}(k-1) \\
-    + \mathbf{U_{max} - T_U u}(k-1)
+    - \mathbf{U_{min} + T_u u}(k-1) \\
+    + \mathbf{U_{max} - T_u u}(k-1)
 \end{bmatrix}
 ```
 in which ``\mathbf{U_{min}}`` and ``\mathbf{U_{max}}`` vectors respectively contains
 ``\mathbf{u_{min}}`` and ``\mathbf{u_{max}}`` repeated ``H_p`` times.
 """
-function relaxU(PU::Matrix{NT}, C_umin, C_umax, nϵ) where NT<:Real
+function relaxU(Pu::Matrix{NT}, C_umin, C_umax, nϵ) where NT<:Real
     if nϵ == 1 # Z̃ = [Z; ϵ]
         # ϵ impacts Z → U conversion for constraint calculations:
-        A_Umin, A_Umax = -[PU  C_umin], [PU -C_umax] 
+        A_Umin, A_Umax = -[Pu  C_umin], [Pu -C_umax] 
         # ϵ has no impact on Z → U conversion for prediction calculations:
-        P̃U = [PU zeros(NT, size(PU, 1))]
+        P̃u = [Pu zeros(NT, size(Pu, 1))]
     else # Z̃ = Z (only hard constraints)
-        A_Umin, A_Umax = -PU,  PU
-        P̃U = PU
+        A_Umin, A_Umax = -Pu,  Pu
+        P̃u = Pu
     end
-    return A_Umin, A_Umax, P̃U
+    return A_Umin, A_Umax, P̃u
 end
 
 @doc raw"""
-    relaxΔU(PΔU, C_Δumin, C_Δumax, ΔUmin, ΔUmax, nϵ) -> A_ΔŨmin, A_ΔŨmax, ΔŨmin, ΔŨmax, P̃ΔU
+    relaxΔU(PΔu, C_Δumin, C_Δumax, ΔUmin, ΔUmax, nϵ) -> A_ΔŨmin, A_ΔŨmax, ΔŨmin, ΔŨmax, P̃Δu
 
 Augment input increments constraints with slack variable ϵ for softening.
 
 Denoting the decision variables augmented with the slack variable 
 ``\mathbf{Z̃} = [\begin{smallmatrix} \mathbf{Z} \\ ϵ \end{smallmatrix}]``, it returns the
-augmented conversion matrix ``\mathbf{P̃_{ΔU}}``, similar to the one described at
+augmented conversion matrix ``\mathbf{P̃_{Δu}}``, similar to the one described at
 [`init_ZtoΔU`](@ref), but extracting the input increments augmented with the slack variable
-``\mathbf{ΔŨ} = [\begin{smallmatrix} \mathbf{ΔU} \\ ϵ \end{smallmatrix}] = \mathbf{P̃_{ΔU} Z̃}``.
+``\mathbf{ΔŨ} = [\begin{smallmatrix} \mathbf{ΔU} \\ ϵ \end{smallmatrix}] = \mathbf{P̃_{Δu} Z̃}``.
 Also, knowing that ``0 ≤ ϵ ≤ ∞``, it also returns the augmented bounds 
 ``\mathbf{ΔŨ_{min}} = [\begin{smallmatrix} \mathbf{ΔU_{min}} \\ 0 \end{smallmatrix}]`` and
 ``\mathbf{ΔŨ_{max}} = [\begin{smallmatrix} \mathbf{ΔU_{min}} \\ ∞ \end{smallmatrix}]``,
@@ -699,19 +699,19 @@ bound, which is more precise than a linear inequality constraint. However, it is
 convenient to treat it as a linear inequality constraint since the optimizer `OSQP.jl` does
 not support pure bounds on the decision variables.
 """
-function relaxΔU(PΔU::Matrix{NT}, C_Δumin, C_Δumax, ΔUmin, ΔUmax, nϵ) where NT<:Real
-    nZ = size(PΔU, 2)
+function relaxΔU(PΔu::Matrix{NT}, C_Δumin, C_Δumax, ΔUmin, ΔUmax, nϵ) where NT<:Real
+    nZ = size(PΔu, 2)
     if nϵ == 1 # Z̃ = [Z; ϵ]
         ΔŨmin, ΔŨmax = [ΔUmin; NT[0.0]], [ΔUmax; NT[Inf]] # 0 ≤ ϵ ≤ ∞
         A_ϵ = [zeros(NT, 1, nZ) NT[1.0]]
-        A_ΔŨmin, A_ΔŨmax = -[PΔU  C_Δumin; A_ϵ], [PΔU -C_Δumax; A_ϵ]
-        P̃ΔU = [PΔU zeros(NT, size(PΔU, 1), 1); zeros(NT, 1, size(PΔU, 2)) NT[1.0]]
+        A_ΔŨmin, A_ΔŨmax = -[PΔu  C_Δumin; A_ϵ], [PΔu -C_Δumax; A_ϵ]
+        P̃Δu = [PΔu zeros(NT, size(PΔu, 1), 1); zeros(NT, 1, size(PΔu, 2)) NT[1.0]]
     else # Z̃ = Z (only hard constraints)
         ΔŨmin, ΔŨmax = ΔUmin, ΔUmax
-        A_ΔŨmin, A_ΔŨmax = -PΔU,  PΔU
-        P̃ΔU = PΔU
+        A_ΔŨmin, A_ΔŨmax = -PΔu,  PΔu
+        P̃Δu = PΔu
     end
-    return A_ΔŨmin, A_ΔŨmax, ΔŨmin, ΔŨmax, P̃ΔU
+    return A_ΔŨmin, A_ΔŨmax, ΔŨmin, ΔŨmax, P̃Δu
 end
 
 @doc raw"""

src/controller/execute.jl

@@ -128,7 +128,7 @@ function getinfo(mpc::PredictiveController{NT}) where NT<:Real
     ΔŨ, Ŷe, Ue = nonlinprog_vectors!(ΔŨ, Ŷe, Ue, Ū, mpc, Ŷ0, Z̃)
     J         = obj_nonlinprog!(Ȳ, Ū, mpc, model, Ue, Ŷe, ΔŨ, Z̃)
     U, Ŷ = Ū, Ȳ
-    U   .= mul!(U, mpc.P̃U, mpc.Z̃) .+ mpc.TU_lastu 
+    U   .= mul!(U, mpc.P̃u, mpc.Z̃) .+ mpc.Tu_lastu 
     Ŷ   .= Ŷ0 .+ mpc.Yop
     predictstoch!(Ŷs, mpc, mpc.estim)
     info[:ΔU]   = Z̃[1:mpc.Hc*model.nu]
@@ -197,7 +197,7 @@ function initpred!(mpc::PredictiveController, model::LinModel, d, D̂, R̂y, R̂
         mul!(F, mpc.G, mpc.d0, 1, 1)            # F = F + G*d0
         mul!(F, mpc.J, mpc.D̂0, 1, 1)            # F = F + J*D̂0
     end
-    Cy, Cu, M_Hp_Ẽ, L_Hp_P̃U = mpc.buffer.Ŷ, mpc.buffer.U, mpc.buffer.Ẽ, mpc.buffer.P̃U
+    Cy, Cu, M_Hp_Ẽ, L_Hp_P̃U = mpc.buffer.Ŷ, mpc.buffer.U, mpc.buffer.Ẽ, mpc.buffer.P̃u
     q̃, r = mpc.q̃, mpc.r
     q̃ .= 0
     r .= 0
@@ -210,9 +210,9 @@ function initpred!(mpc::PredictiveController, model::LinModel, d, D̂, R̂y, R̂
     end
     # --- input setpoint tracking term ---
     if !mpc.weights.iszero_L_Hp[]
-        Cu .= mpc.TU_lastu .- R̂u 
-        mul!(L_Hp_P̃U, mpc.weights.L_Hp, mpc.P̃U)
-        mul!(q̃, L_Hp_P̃U', Cu, 1, 1)             # q̃ = q̃ + L_Hp*P̃U'*Cu
+        Cu .= mpc.Tu_lastu .- R̂u 
+        mul!(L_Hp_P̃U, mpc.weights.L_Hp, mpc.P̃u)
+        mul!(q̃, L_Hp_P̃U', Cu, 1, 1)             # q̃ = q̃ + L_Hp*P̃u'*Cu
         r .+= dot(Cu, mpc.weights.L_Hp, Cu)     # r = r + Cu'*L_Hp*Cu
     end
     # --- finalize ---
@@ -241,7 +241,7 @@ is an [`InternalModel`](@ref). The function returns `mpc.F`.
 function initpred_common!(mpc::PredictiveController, model::SimModel, d, D̂, R̂y, R̂u)
     lastu  = mpc.buffer.u
     lastu .= mpc.estim.lastu0 .+ model.uop
-    mul!(mpc.TU_lastu, mpc.TU, lastu)
+    mul!(mpc.Tu_lastu, mpc.Tu, lastu)
     mpc.ŷ .= evaloutput(mpc.estim, d)
     if model.nd ≠ 0
         mpc.d0 .= d .- model.dop
@@ -288,9 +288,9 @@ function linconstraint!(mpc::PredictiveController, model::LinModel)
         mul!(fx̂, mpc.con.jx̂, mpc.D̂0, 1, 1)
     end
     n = 0
-    mpc.con.b[(n+1):(n+nU)]  .= @. -mpc.con.U0min - mpc.Uop + mpc.TU_lastu
+    mpc.con.b[(n+1):(n+nU)]  .= @. -mpc.con.U0min - mpc.Uop + mpc.Tu_lastu
     n += nU
-    mpc.con.b[(n+1):(n+nU)]  .= @. +mpc.con.U0max + mpc.Uop - mpc.TU_lastu
+    mpc.con.b[(n+1):(n+nU)]  .= @. +mpc.con.U0max + mpc.Uop - mpc.Tu_lastu
     n += nU
     mpc.con.b[(n+1):(n+nΔŨ)] .= @. -mpc.con.ΔŨmin
     n += nΔŨ
@@ -314,9 +314,9 @@ end
 function linconstraint!(mpc::PredictiveController, ::SimModel)
     nU, nΔŨ = length(mpc.con.U0min), length(mpc.con.ΔŨmin)
     n = 0
-    mpc.con.b[(n+1):(n+nU)]  .= @. -mpc.con.U0min - mpc.Uop + mpc.TU_lastu
+    mpc.con.b[(n+1):(n+nU)]  .= @. -mpc.con.U0min - mpc.Uop + mpc.Tu_lastu
     n += nU
-    mpc.con.b[(n+1):(n+nU)]  .= @. +mpc.con.U0max + mpc.Uop - mpc.TU_lastu
+    mpc.con.b[(n+1):(n+nU)]  .= @. +mpc.con.U0max + mpc.Uop - mpc.Tu_lastu
     n += nU
     mpc.con.b[(n+1):(n+nΔŨ)] .= @. -mpc.con.ΔŨmin
     n += nΔŨ
@@ -351,7 +351,7 @@ function nonlinprog_vectors!(ΔŨ, Ŷe, Ue, Ū, mpc::PredictiveController, Y
     nocustomfcts = (mpc.weights.iszero_E && iszero_nc(mpc))
     # --- augmented input increments ΔŨ = [ΔU; ϵ] ---
     if !(mpc.weights.iszero_Ñ_Hc[])
-        ΔŨ .= mul!(ΔŨ, mpc.P̃ΔU, Z̃)
+        ΔŨ .= mul!(ΔŨ, mpc.P̃Δu, Z̃)
     end
     # --- extended output predictions Ŷe = [ŷ(k); Ŷ] ---
     if !(mpc.weights.iszero_M_Hp[] && nocustomfcts)
@@ -361,7 +361,7 @@ function nonlinprog_vectors!(ΔŨ, Ŷe, Ue, Ū, mpc::PredictiveController, Y
     # --- extended manipulated inputs Ue = [U; u(k+Hp-1)] ---
     if !(mpc.weights.iszero_L_Hp[] && nocustomfcts)
         U  = Ū
-        U .= mul!(U, mpc.P̃U, Z̃) .+ mpc.TU_lastu
+        U .= mul!(U, mpc.P̃u, Z̃) .+ mpc.Tu_lastu
         Ue[1:end-nu] .= U
         # u(k + Hp) = u(k + Hp - 1) since Δu(k+Hp) = 0 (because Hc ≤ Hp):
         Ue[end-nu+1:end] .= @views U[end-nu+1:end]
@@ -719,7 +719,7 @@ function setmodel_controller!(mpc::PredictiveController, x̂op_old)
     JuMP.unregister(optim, :linconstrainteq)
     @constraint(optim, linconstrainteq, Aeq*Z̃var .== beq)
     # --- quadratic programming Hessian matrix ---
-    H̃ = init_quadprog(model, mpc.weights, mpc.Ẽ, mpc.P̃ΔU, mpc.P̃U)
+    H̃ = init_quadprog(model, mpc.weights, mpc.Ẽ, mpc.P̃Δu, mpc.P̃u)
     mpc.H̃ .= H̃
     set_objective_hessian!(mpc, Z̃var)
     return nothing

src/controller/explicitmpc.jl

@@ -9,10 +9,10 @@ struct ExplicitMPC{NT<:Real, SE<:StateEstimator} <: PredictiveController{NT}
     weights::ControllerWeights{NT}
     R̂u::Vector{NT}
     R̂y::Vector{NT}
-    P̃ΔU::Matrix{NT}
-    P̃U ::Matrix{NT} 
-    TU ::Matrix{NT}
-    TU_lastu::Vector{NT}
+    P̃Δu::Matrix{NT}
+    P̃u ::Matrix{NT} 
+    Tu ::Matrix{NT}
+    Tu_lastu::Vector{NT}
     Ẽ::Matrix{NT}
     F::Vector{NT}
     G::Matrix{NT}
@@ -46,15 +46,15 @@ struct ExplicitMPC{NT<:Real, SE<:StateEstimator} <: PredictiveController{NT}
         N_Hc = Hermitian(convert(Matrix{NT}, N_Hc), :L)
         L_Hp = Hermitian(convert(Matrix{NT}, L_Hp), :L)
         # dummy vals (updated just before optimization):
-        R̂y, R̂u, TU_lastu = zeros(NT, ny*Hp), zeros(NT, nu*Hp), zeros(NT, nu*Hp)
+        R̂y, R̂u, Tu_lastu = zeros(NT, ny*Hp), zeros(NT, nu*Hp), zeros(NT, nu*Hp)
         transcription = SingleShooting() # explicit MPC only supports SingleShooting
-        PΔU = init_ZtoΔU(estim, transcription, Hp, Hc)
-        PU, TU = init_ZtoU(estim, transcription, Hp, Hc)
+        PΔu = init_ZtoΔU(estim, transcription, Hp, Hc)
+        Pu, Tu = init_ZtoU(estim, transcription, Hp, Hc)
         E, G, J, K, V, B = init_predmat(model, estim, transcription, Hp, Hc)
         # dummy val (updated just before optimization):
         F, fx̂  = zeros(NT, ny*Hp), zeros(NT, nx̂)
-        P̃ΔU, P̃U, Ñ_Hc, Ẽ = PΔU, PU, N_Hc, E # no slack variable ϵ for ExplicitMPC
-        H̃ = init_quadprog(model, weights, Ẽ, P̃ΔU, P̃U)
+        P̃Δu, P̃u, Ñ_Hc, Ẽ = PΔu, Pu, N_Hc, E # no slack variable ϵ for ExplicitMPC
+        H̃ = init_quadprog(model, weights, Ẽ, P̃Δu, P̃u)
         # dummy vals (updated just before optimization):
         q̃, r = zeros(NT, size(H̃, 1)), zeros(NT, 1)
         H̃_chol = cholesky(H̃)
@@ -72,7 +72,7 @@ struct ExplicitMPC{NT<:Real, SE<:StateEstimator} <: PredictiveController{NT}
             Hp, Hc, nϵ,
             weights,
             R̂u, R̂y,
-            P̃ΔU, P̃U, TU, TU_lastu,
+            P̃Δu, P̃u, Tu, Tu_lastu,
             Ẽ, F, G, J, K, V, B,
             H̃, q̃, r,
             H̃_chol,
@@ -225,7 +225,7 @@ function setmodel_controller!(mpc::ExplicitMPC, _ )
     mpc.V .= V
     mpc.B .= B
     # --- quadratic programming Hessian matrix ---
-    H̃ = init_quadprog(model, mpc.weights, mpc.Ẽ, mpc.P̃ΔU, mpc.P̃U)
+    H̃ = init_quadprog(model, mpc.weights, mpc.Ẽ, mpc.P̃Δu, mpc.P̃u)
     mpc.H̃ .= H̃
     set_objective_hessian!(mpc)
     # --- operating points ---

src/controller/linmpc.jl

@@ -21,10 +21,10 @@ struct LinMPC{
     weights::ControllerWeights{NT}
     R̂u::Vector{NT}
     R̂y::Vector{NT}
-    P̃ΔU::Matrix{NT}
-    P̃U ::Matrix{NT} 
-    TU ::Matrix{NT}
-    TU_lastu::Vector{NT}
+    P̃Δu::Matrix{NT}
+    P̃u ::Matrix{NT} 
+    Tu ::Matrix{NT}
+    Tu_lastu::Vector{NT}
     Ẽ::Matrix{NT}
     F::Vector{NT}
     G::Matrix{NT}
@@ -53,22 +53,22 @@ struct LinMPC{
         ŷ = copy(model.yop) # dummy vals (updated just before optimization)
         weights = ControllerWeights{NT}(model, Hp, Hc, M_Hp, N_Hc, L_Hp, Cwt)
         # dummy vals (updated just before optimization):
-        R̂y, R̂u, TU_lastu = zeros(NT, ny*Hp), zeros(NT, nu*Hp), zeros(NT, nu*Hp)
-        PΔU = init_ZtoΔU(estim, transcription, Hp, Hc)
-        PU, TU = init_ZtoU(estim, transcription, Hp, Hc)
+        R̂y, R̂u, Tu_lastu = zeros(NT, ny*Hp), zeros(NT, nu*Hp), zeros(NT, nu*Hp)
+        PΔu = init_ZtoΔU(estim, transcription, Hp, Hc)
+        Pu, Tu = init_ZtoU(estim, transcription, Hp, Hc)
         E, G, J, K, V, B, ex̂, gx̂, jx̂, kx̂, vx̂, bx̂ = init_predmat(
             model, estim, transcription, Hp, Hc
         )
         Eŝ, Gŝ, Jŝ, Kŝ, Vŝ, Bŝ = init_defectmat(model, estim, transcription, Hp, Hc)
         # dummy vals (updated just before optimization):
         F, fx̂, Fŝ  = zeros(NT, ny*Hp), zeros(NT, nx̂), zeros(NT, nx̂*Hp)
-        con, nϵ, P̃ΔU, P̃U, Ẽ, Ẽŝ = init_defaultcon_mpc(
+        con, nϵ, P̃Δu, P̃u, Ẽ, Ẽŝ = init_defaultcon_mpc(
             estim, transcription,
-            Hp, Hc, Cwt, PΔU, PU, E, 
+            Hp, Hc, Cwt, PΔu, Pu, E, 
             ex̂, fx̂, gx̂, jx̂, kx̂, vx̂, bx̂, 
             Eŝ, Fŝ, Gŝ, Jŝ, Kŝ, Vŝ, Bŝ
         )
-        H̃ = init_quadprog(model, weights, Ẽ, P̃ΔU, P̃U)
+        H̃ = init_quadprog(model, weights, Ẽ, P̃Δu, P̃u)
         # dummy vals (updated just before optimization):
         q̃, r = zeros(NT, size(H̃, 1)), zeros(NT, 1)
         Ks, Ps = init_stochpred(estim, Hp)
@@ -84,7 +84,7 @@ struct LinMPC{
             Hp, Hc, nϵ,
             weights,
             R̂u, R̂y,
-            P̃ΔU, P̃U, TU, TU_lastu,
+            P̃Δu, P̃u, Tu, Tu_lastu,
             Ẽ, F, G, J, K, V, B, 
             H̃, q̃, r,
             Ks, Ps,