changed: DimensionMistmatch instead of ArgumentError in setconstraint!

Author: franckgaga

src/controller/construct.jl

@@ -349,84 +349,84 @@ function setconstraint!(
     nϵ, nw, nc = mpc.nϵ, con.nw, con.nc
     notSolvedYet = (JuMP.termination_status(optim) == JuMP.OPTIMIZE_NOT_CALLED)
     if isnothing(Umin) && !isnothing(umin)
-        size(umin) == (nu,) || throw(ArgumentError("umin size must be $((nu,))"))
+        size(umin) == (nu,) || throw(DimensionMismatch("umin size must be $((nu,))"))
         for i = 1:nu*Hp
             con.U0min[i] = umin[(i-1) % nu + 1] - mpc.Uop[i]
         end
     elseif !isnothing(Umin)
-        size(Umin) == (nu*Hp,) || throw(ArgumentError("Umin size must be $((nu*Hp,))"))
+        size(Umin) == (nu*Hp,) || throw(DimensionMismatch("Umin size must be $((nu*Hp,))"))
         con.U0min .= Umin .- mpc.Uop
     end
     if isnothing(Umax) && !isnothing(umax)
-        size(umax) == (nu,) || throw(ArgumentError("umax size must be $((nu,))"))
+        size(umax) == (nu,) || throw(DimensionMismatch("umax size must be $((nu,))"))
         for i = 1:nu*Hp
             con.U0max[i] = umax[(i-1) % nu + 1] - mpc.Uop[i]
         end
     elseif !isnothing(Umax)
-        size(Umax)   == (nu*Hp,) || throw(ArgumentError("Umax size must be $((nu*Hp,))"))
+        size(Umax)   == (nu*Hp,) || throw(DimensionMismatch("Umax size must be $((nu*Hp,))"))
         con.U0max .= Umax .- mpc.Uop
     end
     if isnothing(ΔUmin) && !isnothing(Δumin)
-        size(Δumin) == (nu,) || throw(ArgumentError("Δumin size must be $((nu,))"))
+        size(Δumin) == (nu,) || throw(DimensionMismatch("Δumin size must be $((nu,))"))
         for i = 1:nu*Hc
             con.ΔŨmin[i] = Δumin[(i-1) % nu + 1]
         end
     elseif !isnothing(ΔUmin)
-        size(ΔUmin)  == (nu*Hc,) || throw(ArgumentError("ΔUmin size must be $((nu*Hc,))"))
+        size(ΔUmin)  == (nu*Hc,) || throw(DimensionMismatch("ΔUmin size must be $((nu*Hc,))"))
         con.ΔŨmin[1:nu*Hc] .= ΔUmin
     end
     if isnothing(ΔUmax) && !isnothing(Δumax)
-        size(Δumax) == (nu,) || throw(ArgumentError("Δumax size must be $((nu,))"))
+        size(Δumax) == (nu,) || throw(DimensionMismatch("Δumax size must be $((nu,))"))
         for i = 1:nu*Hc
             con.ΔŨmax[i] = Δumax[(i-1) % nu + 1]
         end
     elseif !isnothing(ΔUmax)
-        size(ΔUmax)  == (nu*Hc,) || throw(ArgumentError("ΔUmax size must be $((nu*Hc,))"))
+        size(ΔUmax)  == (nu*Hc,) || throw(DimensionMismatch("ΔUmax size must be $((nu*Hc,))"))
         con.ΔŨmax[1:nu*Hc] .= ΔUmax
     end
     if isnothing(Ymin) && !isnothing(ymin)
-        size(ymin) == (ny,) || throw(ArgumentError("ymin size must be $((ny,))"))
+        size(ymin) == (ny,) || throw(DimensionMismatch("ymin size must be $((ny,))"))
         for i = 1:ny*Hp
             con.Y0min[i] = ymin[(i-1) % ny + 1] - mpc.Yop[i]
         end
     elseif !isnothing(Ymin)
-        size(Ymin) == (ny*Hp,) || throw(ArgumentError("Ymin size must be $((ny*Hp,))"))
+        size(Ymin) == (ny*Hp,) || throw(DimensionMismatch("Ymin size must be $((ny*Hp,))"))
         con.Y0min .= Ymin .- mpc.Yop
     end
     if isnothing(Ymax) && !isnothing(ymax)
-        size(ymax) == (ny,) || throw(ArgumentError("ymax size must be $((ny,))"))
+        size(ymax) == (ny,) || throw(DimensionMismatch("ymax size must be $((ny,))"))
         for i = 1:ny*Hp
             con.Y0max[i] = ymax[(i-1) % ny + 1] - mpc.Yop[i]
         end
     elseif !isnothing(Ymax)
-        size(Ymax) == (ny*Hp,) || throw(ArgumentError("Ymax size must be $((ny*Hp,))"))
+        size(Ymax) == (ny*Hp,) || throw(DimensionMismatch("Ymax size must be $((ny*Hp,))"))
         con.Y0max .= Ymax .- mpc.Yop
     end
 
     if isnothing(Wmin) && !isnothing(wmin)
-        size(wmin) == (nw,) || throw(ArgumentError("wmin size must be $((nw,))"))
+        size(wmin) == (nw,) || throw(DimensionMismatch("wmin size must be $((nw,))"))
         for i = 1:nw*(Hp+1)
             con.Wmin[i] = wmin[(i-1) % nw + 1]
         end
     elseif !isnothing(Wmin)
-        size(Wmin) == (nw*(Hp+1),) || throw(ArgumentError("Wmin size must be $((nw*(Hp+1),))"))
+        size(Wmin) == (nw*(Hp+1),) || throw(DimensionMismatch("Wmin size must be $((nw*(Hp+1),))"))
         con.Wmin .= Wmin
     end
     if isnothing(Wmax) && !isnothing(wmax)
-        size(wmax) == (nw,) || throw(ArgumentError("wmax size must be $((nw,))"))
+        size(wmax) == (nw,) || throw(DimensionMismatch("wmax size must be $((nw,))"))
         for i = 1:nw*(Hp+1)
             con.Wmax[i] = wmax[(i-1) % nw + 1]
         end
     elseif !isnothing(Wmax)
-        size(Wmax) == (nw*(Hp+1),) || throw(ArgumentError("Wmax size must be $((nw*(Hp+1),))"))
+        size(Wmax) == (nw*(Hp+1),) || throw(DimensionMismatch("Wmax size must be $((nw*(Hp+1),))"))
         con.Wmax .= Wmax
     end
     if !isnothing(x̂min)
-        size(x̂min) == (nx̂,) || throw(ArgumentError("x̂min size must be $((nx̂,))"))
+        size(x̂min) == (nx̂,) || throw(DimensionMismatch("x̂min size must be $((nx̂,))"))
         con.x̂0min .= x̂min .- mpc.estim.x̂op
     end
     if !isnothing(x̂max)
-        size(x̂max) == (nx̂,) || throw(ArgumentError("x̂max size must be $((nx̂,))"))
+        size(x̂max) == (nx̂,) || throw(DimensionMismatch("x̂max size must be $((nx̂,))"))
         con.x̂0max .= x̂max .- mpc.estim.x̂op
     end
     allECRs = (
@@ -448,57 +448,57 @@ function setconstraint!(
         isnothing(C_wmin)   && !isnothing(c_wmin)   && (C_wmin  = repeat(c_wmin,  Hp+1))
         isnothing(C_wmax)   && !isnothing(c_wmax)   && (C_wmax  = repeat(c_wmax,  Hp+1))
         if !isnothing(C_umin)
-            size(C_umin) == (nu*Hp,) || throw(ArgumentError("C_umin size must be $((nu*Hp,))"))
+            size(C_umin) == (nu*Hp,) || throw(DimensionMismatch("C_umin size must be $((nu*Hp,))"))
             any(<(0), C_umin) && error("C_umin weights should be non-negative")
             con.A_Umin[:, end] .= -C_umin
         end
         if !isnothing(C_umax)
-            size(C_umax) == (nu*Hp,) || throw(ArgumentError("C_umax size must be $((nu*Hp,))"))
+            size(C_umax) == (nu*Hp,) || throw(DimensionMismatch("C_umax size must be $((nu*Hp,))"))
             any(<(0), C_umax) && error("C_umax weights should be non-negative")
             con.A_Umax[:, end] .= -C_umax
         end
         if !isnothing(C_Δumin)
-            size(C_Δumin) == (nu*Hc,) || throw(ArgumentError("C_Δumin size must be $((nu*Hc,))"))
+            size(C_Δumin) == (nu*Hc,) || throw(DimensionMismatch("C_Δumin size must be $((nu*Hc,))"))
             any(<(0), C_Δumin) && error("C_Δumin weights should be non-negative")
             con.A_ΔŨmin[1:end-1, end] .= -C_Δumin 
         end
         if !isnothing(C_Δumax)
-            size(C_Δumax) == (nu*Hc,) || throw(ArgumentError("C_Δumax size must be $((nu*Hc,))"))
+            size(C_Δumax) == (nu*Hc,) || throw(DimensionMismatch("C_Δumax size must be $((nu*Hc,))"))
             any(<(0), C_Δumax) && error("C_Δumax weights should be non-negative")
             con.A_ΔŨmax[1:end-1, end] .= -C_Δumax
         end
         if !isnothing(C_ymin)
-            size(C_ymin) == (ny*Hp,) || throw(ArgumentError("C_ymin size must be $((ny*Hp,))"))
+            size(C_ymin) == (ny*Hp,) || throw(DimensionMismatch("C_ymin size must be $((ny*Hp,))"))
             any(<(0), C_ymin) && error("C_ymin weights should be non-negative")
             con.C_ymin .= C_ymin
             size(con.A_Ymin, 1) ≠ 0 && (con.A_Ymin[:, end] .= -con.C_ymin) # for LinModel
         end
         if !isnothing(C_ymax)
-            size(C_ymax) == (ny*Hp,) || throw(ArgumentError("C_ymax size must be $((ny*Hp,))"))
+            size(C_ymax) == (ny*Hp,) || throw(DimensionMismatch("C_ymax size must be $((ny*Hp,))"))
             any(<(0), C_ymax) && error("C_ymax weights should be non-negative")
             con.C_ymax .= C_ymax
             size(con.A_Ymax, 1) ≠ 0 && (con.A_Ymax[:, end] .= -con.C_ymax) # for LinModel
         end
         if !isnothing(C_wmin)
-            size(C_wmin) == (nw*(Hp+1),) || throw(ArgumentError("C_wmin size must be $((nw*(Hp+1),))"))
+            size(C_wmin) == (nw*(Hp+1),) || throw(DimensionMismatch("C_wmin size must be $((nw*(Hp+1),))"))
             any(<(0), C_wmin) && error("C_wmin weights should be non-negative")
             con.C_wmin .= C_wmin
             con.A_Wmin[:, end] .= -C_wmin
         end
         if !isnothing(C_wmax)
-            size(C_wmax) == (nw*(Hp+1),) || throw(ArgumentError("C_wmax size must be $((nw*(Hp+1),))"))
+            size(C_wmax) == (nw*(Hp+1),) || throw(DimensionMismatch("C_wmax size must be $((nw*(Hp+1),))"))
             any(<(0), C_wmax) && error("C_wmax weights should be non-negative")
             con.C_wmax .= C_wmax
             con.A_Wmax[:, end] .= -C_wmax
         end
         if !isnothing(c_x̂min)
-            size(c_x̂min) == (nx̂,) || throw(ArgumentError("c_x̂min size must be $((nx̂,))"))
+            size(c_x̂min) == (nx̂,) || throw(DimensionMismatch("c_x̂min size must be $((nx̂,))"))
             any(<(0), c_x̂min) && error("c_x̂min weights should be non-negative")
             con.c_x̂min .= c_x̂min
             size(con.A_x̂min, 1) ≠ 0 && (con.A_x̂min[:, end] .= -con.c_x̂min) # for LinModel
         end
         if !isnothing(c_x̂max)
-            size(c_x̂max) == (nx̂,) || throw(ArgumentError("c_x̂max size must be $((nx̂,))"))
+            size(c_x̂max) == (nx̂,) || throw(DimensionMismatch("c_x̂max size must be $((nx̂,))"))
             any(<(0), c_x̂max) && error("c_x̂max weights should be non-negative")
             con.c_x̂max .= c_x̂max
             size(con.A_x̂max, 1) ≠ 0 && (con.A_x̂max[:, end] .= -con.c_x̂max) # for LinModel

src/estimator/mhe/construct.jl

@@ -621,61 +621,61 @@ function setconstraint!(
     notSolvedYet = (JuMP.termination_status(optim) == JuMP.OPTIMIZE_NOT_CALLED)
     C = estim.C
     if isnothing(X̂min) && !isnothing(x̂min)
-        size(x̂min) == (nx̂,) || throw(ArgumentError("x̂min size must be $((nx̂,))"))
+        size(x̂min) == (nx̂,) || throw(DimensionMismatch("x̂min size must be $((nx̂,))"))
         con.x̃0min[end-nx̂+1:end] .= x̂min .- estim.x̂op # if C is finite : x̃ = [ε; x̂]
         for i in 1:nx̂*He
             con.X̂0min[i] = x̂min[(i-1) % nx̂ + 1] - estim.X̂op[i]
         end
     elseif !isnothing(X̂min)
-        size(X̂min) == (nX̂con,) || throw(ArgumentError("X̂min size must be $((nX̂con,))"))
+        size(X̂min) == (nX̂con,) || throw(DimensionMismatch("X̂min size must be $((nX̂con,))"))
         con.x̃0min[end-nx̂+1:end] .= X̂min[1:nx̂] .- estim.x̂op
         con.X̂0min .= @views X̂min[nx̂+1:end] .- estim.X̂op
     end
     if isnothing(X̂max) && !isnothing(x̂max)
-        size(x̂max) == (nx̂,) || throw(ArgumentError("x̂max size must be $((nx̂,))"))
+        size(x̂max) == (nx̂,) || throw(DimensionMismatch("x̂max size must be $((nx̂,))"))
         con.x̃0max[end-nx̂+1:end] .= x̂max .- estim.x̂op # if C is finite : x̃ = [ε; x̂]
         for i in 1:nx̂*He
             con.X̂0max[i] = x̂max[(i-1) % nx̂ + 1] - estim.X̂op[i]
         end
     elseif !isnothing(X̂max)
-        size(X̂max) == (nX̂con,) || throw(ArgumentError("X̂max size must be $((nX̂con,))"))
+        size(X̂max) == (nX̂con,) || throw(DimensionMismatch("X̂max size must be $((nX̂con,))"))
         con.x̃0max[end-nx̂+1:end] .= X̂max[1:nx̂] .- estim.x̂op
         con.X̂0max .= @views X̂max[nx̂+1:end] .- estim.X̂op
     end
     if isnothing(Ŵmin) && !isnothing(ŵmin)
-        size(ŵmin) == (nŵ,) || throw(ArgumentError("ŵmin size must be $((nŵ,))"))
+        size(ŵmin) == (nŵ,) || throw(DimensionMismatch("ŵmin size must be $((nŵ,))"))
         for i in 1:nŵ*He
             con.Ŵmin[i] = ŵmin[(i-1) % nŵ + 1]
         end
     elseif !isnothing(Ŵmin)
-        size(Ŵmin) == (nŵ*He,) || throw(ArgumentError("Ŵmin size must be $((nŵ*He,))"))
+        size(Ŵmin) == (nŵ*He,) || throw(DimensionMismatch("Ŵmin size must be $((nŵ*He,))"))
         con.Ŵmin .= Ŵmin
     end
     if isnothing(Ŵmax) && !isnothing(ŵmax)
-        size(ŵmax) == (nŵ,) || throw(ArgumentError("ŵmax size must be $((nŵ,))"))
+        size(ŵmax) == (nŵ,) || throw(DimensionMismatch("ŵmax size must be $((nŵ,))"))
         for i in 1:nŵ*He
             con.Ŵmax[i] = ŵmax[(i-1) % nŵ + 1]
         end
     elseif !isnothing(Ŵmax)
-        size(Ŵmax) == (nŵ*He,) || throw(ArgumentError("Ŵmax size must be $((nŵ*He,))"))
+        size(Ŵmax) == (nŵ*He,) || throw(DimensionMismatch("Ŵmax size must be $((nŵ*He,))"))
         con.Ŵmax .= Ŵmax
     end
     if isnothing(V̂min) && !isnothing(v̂min)
-        size(v̂min) == (nym,) || throw(ArgumentError("v̂min size must be $((nym,))"))
+        size(v̂min) == (nym,) || throw(DimensionMismatch("v̂min size must be $((nym,))"))
         for i in 1:nym*He
             con.V̂min[i] = v̂min[(i-1) % nym + 1]
         end
     elseif !isnothing(V̂min)
-        size(V̂min) == (nym*He,) || throw(ArgumentError("V̂min size must be $((nym*He,))"))
+        size(V̂min) == (nym*He,) || throw(DimensionMismatch("V̂min size must be $((nym*He,))"))
         con.V̂min .= V̂min
     end
     if isnothing(V̂max) && !isnothing(v̂max)
-        size(v̂max) == (nym,) || throw(ArgumentError("v̂max size must be $((nym,))"))
+        size(v̂max) == (nym,) || throw(DimensionMismatch("v̂max size must be $((nym,))"))
         for i in 1:nym*He
             con.V̂max[i] = v̂max[(i-1) % nym + 1]
         end
     elseif !isnothing(V̂max)
-        size(V̂max) == (nym*He,) || throw(ArgumentError("V̂max size must be $((nym*He,))"))
+        size(V̂max) == (nym*He,) || throw(DimensionMismatch("V̂max size must be $((nym*He,))"))
         con.V̂max .= V̂max
     end
     allECRs = (
@@ -694,39 +694,39 @@ function setconstraint!(
         isnothing(C_v̂min) && !isnothing(c_v̂min) && (C_v̂min = repeat(c_v̂min, He))
         isnothing(C_v̂max) && !isnothing(c_v̂max) && (C_v̂max = repeat(c_v̂max, He))
         if !isnothing(C_x̂min)
-            size(C_x̂min) == (nX̂con,) || throw(ArgumentError("C_x̂min size must be $((nX̂con,))"))
+            size(C_x̂min) == (nX̂con,) || throw(DimensionMismatch("C_x̂min size must be $((nX̂con,))"))
             any(C_x̂min .< 0) && error("C_x̂min weights should be non-negative")
             # if C is finite : x̃ = [ε; x̂] 
             con.A_x̃min[end-nx̂+1:end, end] .= @views -C_x̂min[1:nx̂] 
             con.C_x̂min .= @views C_x̂min[nx̂+1:end]
             size(con.A_X̂min, 1) ≠ 0 && (con.A_X̂min[:, end] = -con.C_x̂min) # for LinModel
         end
         if !isnothing(C_x̂max)
-            size(C_x̂max) == (nX̂con,) || throw(ArgumentError("C_x̂max size must be $((nX̂con,))"))
+            size(C_x̂max) == (nX̂con,) || throw(DimensionMismatch("C_x̂max size must be $((nX̂con,))"))
             any(C_x̂max .< 0) && error("C_x̂max weights should be non-negative")
             # if C is finite : x̃ = [ε; x̂] :
             con.A_x̃max[end-nx̂+1:end, end] .= @views -C_x̂max[1:nx̂]
             con.C_x̂max .= @views C_x̂max[nx̂+1:end]
             size(con.A_X̂max, 1) ≠ 0 && (con.A_X̂max[:, end] = -con.C_x̂max) # for LinModel
         end
         if !isnothing(C_ŵmin)
-            size(C_ŵmin) == (nŵ*He,) || throw(ArgumentError("C_ŵmin size must be $((nŵ*He,))"))
+            size(C_ŵmin) == (nŵ*He,) || throw(DimensionMismatch("C_ŵmin size must be $((nŵ*He,))"))
             any(C_ŵmin .< 0) && error("C_ŵmin weights should be non-negative")
             con.A_Ŵmin[:, end] .= -C_ŵmin
         end
         if !isnothing(C_ŵmax)
-            size(C_ŵmax) == (nŵ*He,) || throw(ArgumentError("C_ŵmax size must be $((nŵ*He,))"))
+            size(C_ŵmax) == (nŵ*He,) || throw(DimensionMismatch("C_ŵmax size must be $((nŵ*He,))"))
             any(C_ŵmax .< 0) && error("C_ŵmax weights should be non-negative")
             con.A_Ŵmax[:, end] .= -C_ŵmax
         end
         if !isnothing(C_v̂min)
-            size(C_v̂min) == (nym*He,) || throw(ArgumentError("C_v̂min size must be $((nym*He,))"))
+            size(C_v̂min) == (nym*He,) || throw(DimensionMismatch("C_v̂min size must be $((nym*He,))"))
             any(C_v̂min .< 0) && error("C_v̂min weights should be non-negative")
             con.C_v̂min .= C_v̂min
             size(con.A_V̂min, 1) ≠ 0 && (con.A_V̂min[:, end] = -con.C_v̂min) # for LinModel
         end
         if !isnothing(C_v̂max)
-            size(C_v̂max) == (nym*He,) || throw(ArgumentError("C_v̂max size must be $((nym*He,))"))
+            size(C_v̂max) == (nym*He,) || throw(DimensionMismatch("C_v̂max size must be $((nym*He,))"))
             any(C_v̂max .< 0) && error("C_v̂max weights should be non-negative")
             con.C_v̂max .= C_v̂max
             size(con.A_V̂max, 1) ≠ 0 && (con.A_V̂max[:, end] = -con.C_v̂max) # for LinModel

test/2_test_state_estim.jl

@@ -1231,18 +1231,18 @@ end
     @test mhe3.con.C_v̂min ≈ 0.03(11:18)
     @test mhe3.con.C_v̂max ≈ 0.04(11:18)
 
-    @test_throws ArgumentError setconstraint!(mhe2, x̂min=[-1])
-    @test_throws ArgumentError setconstraint!(mhe2, x̂max=[+1])
-    @test_throws ArgumentError setconstraint!(mhe2, ŵmin=[-1])
-    @test_throws ArgumentError setconstraint!(mhe2, ŵmax=[+1])
-    @test_throws ArgumentError setconstraint!(mhe2, v̂min=[-1])
-    @test_throws ArgumentError setconstraint!(mhe2, v̂max=[+1])
-    @test_throws ArgumentError setconstraint!(mhe2, c_x̂min=[-1])
-    @test_throws ArgumentError setconstraint!(mhe2, c_x̂max=[+1])
-    @test_throws ArgumentError setconstraint!(mhe2, c_ŵmin=[-1])
-    @test_throws ArgumentError setconstraint!(mhe2, c_ŵmax=[+1])
-    @test_throws ArgumentError setconstraint!(mhe2, c_v̂min=[-1])
-    @test_throws ArgumentError setconstraint!(mhe2, c_v̂max=[+1])
+    @test_throws DimensionMismatch setconstraint!(mhe2, x̂min=[-1])
+    @test_throws DimensionMismatch setconstraint!(mhe2, x̂max=[+1])
+    @test_throws DimensionMismatch setconstraint!(mhe2, ŵmin=[-1])
+    @test_throws DimensionMismatch setconstraint!(mhe2, ŵmax=[+1])
+    @test_throws DimensionMismatch setconstraint!(mhe2, v̂min=[-1])
+    @test_throws DimensionMismatch setconstraint!(mhe2, v̂max=[+1])
+    @test_throws DimensionMismatch setconstraint!(mhe2, c_x̂min=[+2])
+    @test_throws DimensionMismatch setconstraint!(mhe2, c_x̂max=[+1])
+    @test_throws DimensionMismatch setconstraint!(mhe2, c_ŵmin=[+2])
+    @test_throws DimensionMismatch setconstraint!(mhe2, c_ŵmax=[+1])
+    @test_throws DimensionMismatch setconstraint!(mhe2, c_v̂min=[+2])
+    @test_throws DimensionMismatch setconstraint!(mhe2, c_v̂max=[+1])
 
     preparestate!(mhe1, [50, 30])
     updatestate!(mhe1, [10, 50], [50, 30])