Hard Limits, Ramp Limits and Non-Windup PI Controllers

[rodrigomha]

@jd-lara @duncancallaway @m-bossart @ciaranrob
Hello, this discussion post serves as a starting point for our discussion on implementing limits on models in a general form.

Hard Limits

First of all, I want to mention that a hard limit is implemented directly in Julia using the clamp function. The clamp function is the clip function typically used in Python. That is a block of the form:

Can be implemented directly in Julia as:
y = clamp(x, x_min, x_max)

Ramp Limits

Second, it is common to find the following block that includes both hard limits and ramp limits in a low-pass filter block:

The first thing to note is that both options can be implemented using two clamp functions. First thing to remember is that a low-pass filter without limits is modeled as follows:

dy = (1.0 / T_g) * (x - y)

It is not clear for me yet, what is the standard implementation of this block including limits, but I have seen the following two implementations:

The only difference between two options is if the time constant is considered for the ramp limits. The implementation for option A and B is as follows:

# Option A
y_no_sat = state[1] #This implementation requires that the actual state is not saturated
y = clamp(y_no_sat, x_min, x_max)
binary_logic = x_min < y_no_sat < x_max ? 1.0 : 0.0
err_sat = clamp(x - y, dx_min, dx_max)
dy_no_sat = binary_logic * (1.0 / T_g) * err_sat

# Option B
y_no_sat = state[1] #This implementation requires that the actual state is not saturated
binary_logic = x_min < y_no_sat < x_max ? 1.0 : 0.0
y = clamp(y_no_sat, x_min, x_max)
err_sat = clamp( (1.0 / T_g) * (x - y), dx_min, dx_max)
dy_no_sat =  binary_logic * err_sat

We can implement a wrapper function that returns both the derivative and the saturated output:

# Option A
function low_pass_ramp_limits(x, y_no_sat, x_min, x_max, dx_min, dx_max, T_g)
    binary_logic = x_min < y_no_sat < x_max ? 1.0 : 0.0
    y = clamp(y_no_sat, x_min, x_max)
    err_sat = clamp(x - y, dx_min, dx_max)
    dy_no_sat = binary_logic * (1.0 / T_g) * err_sat
    return y, dy_no_sat
end

An inconvenience of this implementation, is that if the user wants to plot y after the simulation is over, it will return the non-saturated value.

Non-Windup PI Controller

Finally, the Non-Windup PI controller, is usually find in the following form:

The standard implementation (that can lead to trajectory deadlock) is the following:

Note that in this block the code is as follows:

z = state[1] #This implementation requires that the actual state is not saturated
y_no_sat = K_p * x + K_i * z
y = clamp(y_no_sat, x_min, x_max)
# If the output is outside the limits, set the derivative of the integrator state to zero
limit_binary = x_min < y_no_sat < x_max ? 1.0 : 0.0 
dz = limit_binary * x

Again we can wrap the PI block in a function as follows:

function PI_non_windup(x, z, x_min, x_max, K_p, K_i)
   y_no_sat = K_p * x + K_i * z
   y = clamp(y_no_sat, x_min, x_max)
   limit_binary = x_min < y_no_sat < x_max ? 1.0 : 0.0
   dz = limit_binary * x
   return y, dz
end

A discussion of implementing the solution proposed by Hiskens in the paper is an alternative also, but requires augmenting the states of the model.

Finally, this is the proposed implementation for doing it directly in the model function. The callback implementation requires a different approach to design the affects and conditions (although will be similar at the code presented here).