The repeatable behavior of a linear process allows a process controller to predict the future effects of its current efforts. As described in “Process Controllers Predict the Future” (March 2008), a controller’s predictive abilities can be reduced to a mathematical formula by conducting the following experiment:

1) Stimulate the process in open-loop mode by forcing the controller to apply a unity impulse; that is, a single control effort that is one unit in magnitude and Δt seconds in duration.

2) Determine the process’s open-loop impulse response by measuring the process variable every Δt seconds after the impulse.

3) Label those measurements in chronological order as h(0), h(1), h(2), etc. and construct a single infinitely long “number” H using those values as “digits”. That is, let

H = h(0), h(1), h(2), …

4) Start over and let the controller apply an arbitrary sequence of control efforts to the process. Label those values u(0), u(1), u(2), etc., and use them to construct a second infinitely long number U:

U = u(0), u(1), u(2), …

5) Compute Y = H*U using convolution, which multiplies H and U together just as if they were normal multi-digit numbers. That is, use normal multiplication and addition to compute

y(0) = u(0) · h(0)

y(1) = u(0) · h(1) + u(1) · h(0)

y(2) = u(0) · h(2) + u(1) · h(1) + u(2) · h(0)

and so on until the kth sampling interval when

y(k) = u(0) · h(k) + u(1) · h(k-1) + …

+u(k-1) · h(1) + u(k) · h(0)

The behavior of this closed-loop control system can be predicted by constructing four “numbers” – S, D, G, and H - with “digits” consisting of sampled values of the setpoint, the disturbance, the open-loop impulse response of the process, and the open-loop impulse response of the controller, respectively.  The sequence of  process variable measurements Y that will result from any given combination of S, D, G, and H can then be computed from Y =     G * H     * S +         1        * D        1 + G * H            1 + G * H where the star (*) indicates convolution and the two quotients indicate deconvolution.

Conversely, the equations in step 5 could be solved for the open-loop control efforts U that would be necessary to generate a specified sequence of process variable measurements Y. That is, pick the desired values of

Y = y(0), y(1), y(2), …

and let

u(0) =y(0)

h(0)

u(1) = 1 [y(1) - u(0) · h(1)]

h(0)

u(2) = 1 [y(2) - u(0) · h(2) - u(1) · h(1)]

h(0)

and so on until the kth sampling interval when

u(k) = 1 [y(k) - u(0) · h(k) - u(1) · h(k -1) - …

h(0)

- u(k-1) · h(1)]

This operation, known appropriately enough as deconvolution, is essentially the long division algorithm applied to dividing Y by H to get U = Y/H. See the “Deconvolution example” graphic.

In practice, process controllers typically compute their control efforts using algorithms more sophisticated than open-loop control, but convolution and deconvolution can be used to analyze the behavior of closed-loop control systems as well.

Consider, for example, the basic feedback control system shown in the “Analyzing feedback loops” graphic. The process variable is sampled at regular intervals, and each measurement is subtracted from the setpoint to generate a sequence of error measurements. Those are fed into a controller that, in turn, generates a sequence of control efforts chosen to drive the process variable toward the setpoint.

The resulting process variable measurements Y will equal the results of the controller’s efforts added to any uncontrollable disturbances D that might also be affecting the process. In terms of the convolution operator, that sum can be expressed as

Y = H * U + D

If the controller is also a linear process (and most are), then

U = G * E

where G is the impulse response of the controller, S is the setpoint sequence and

E = S - Y

is the error sequence. These three relationships can be combined by means of simple algebra, treating convolution just like multiplication and deconvolution just like division. That is,

Y = G * H * (S - Y) + D

or

Y = G * H * S + 1 * D

1 + G * H 1 + G * H

This formula predicts the process variable measurements Y that will result from any given combination of setpoints S and disturbances D when a process with an open-loop impulse response of H is controlled by a feedback controller with an open-loop impulse response of G. It is the fundamental mathematical tool used by control theorists to design controllers and analyze their closed-loop behavior.

For example, the quantity

T_S = G * H

1 + G * H

known as the transfer function between the setpoint and the process variable, can be used to determine how the process variable Y will react to any given sequence of setpoints S in the absence of disturbances. That is, let D=0 so that

Y = T_S * S

The sequence T_S is also the impulse response of the closed-loop system. That is, T_S shows what the process variable would look like if a unity impulse were to be substituted for the setpoint while the controller is on-line controlling the process.

This phenomenon yields a test for closed-loop stability of a feedback control system. If the impulse responses of the controller and open-loop process are both known, then their convolution product G*H can be used to compute T_S. If all of the digits of T_S turn out to be finite, then the closed-loop system will be stable. Otherwise, Y = T_S*S will grow forever no matter what values are chosen for S, and the closed-loop system will be unstable. See the “Stability test” graphic.

On the other hand, if the setpoint S is zero and the controller is only concerned with counteracting the effects of disturbances, then

Y = T_D * D

where the quantity

T_D = 1

1 + G * H

is the transfer function between the disturbance sequence D and the process variable Y. It shows what the process variable would look like if the closed-loop system were to be stimulated with a single, unity-impulse disturbance. It too can be computed from G*H, though it will typically have a different value than T_S. This is why a closed-loop system’s disturbance response typically differs from its setpoint response, though if one is stable, so will the other.

The transfer functions T_S and T_D can also be used to design the controller if H is known and G has not already been selected. For example, if the controller will be used primarily to track setpoint changes, T_S can be assigned a suitable value that will produce some desirable closed-loop setpoint response. The controller required to achieve that particular setpoint response would then be given by

G = T_S

H * (1 - T_S)

Similarly, if the controller will be used primarily to reject disturbances, then T_D can be assigned a suitable value, and the controller’s impulse response can be set to

G = 1 - T_D

H * T_D

Devising a controller that will demonstrate either of these impulse response sequences exactly can be a bit tricky, but there are mathematical techniques collectively known as transform theory that can help. The first step is to express G and H as fractions with numerators and denominators of finite length. For example, the infinitely long open-loop impulse response

H = 16, 4, 1, ¼, ...

can also be expressed as H=A/B with

A = 16

B = 1, -¼

in much the same way as the infinitely long decimal value 0.14285... can be expressed as 1/7. In fact, deconvolution and normal division are essentially the same algorithm. See the “Deconvolution example” graphic.

The simplified version of H can also be converted into a Z transform that can be used to analyze a closed-loop system’s behavior without having to perform any convolution operations involving infinitely long sequences of sampled data. Unfortunately, it takes considerably more mathematical expertise to understand how and why Z transforms work.

Z transforms can be converted into Laplace and Fourier transforms by decreasing the sampling interval Δt to zero. These transforms can be used to analyze the behavior of analog control systems where data is processed in a continuous stream rather than at regular intervals.