Decoupling Controller for a Distillation Column

This example shows how to use Robust Control Toolbox™ to decouple the two main feedback loops in a distillation column.

Distillation Column Model

This example uses a simple model of the distillation column shown below.

Figure 1: Distillation Column

In the so-called LV configuration, the controlled variables are the concentrations yD and yB of the chemicals D (tops) and B (bottoms), and the manipulated variables are the reflux L and boilup V. This process exhibits strong coupling and large variations in steady-state gain for some combinations of L and V. For more details, see Skogestad and Postlethwaite, Multivariable Feedback Control.

The plant is modeled as a first-order transfer function with inputs L,V and outputs yD,yB:

$$ G(s) = \frac{1}{75s+1} \left ( \begin{array}{cc} 87.8 & -86.4 \\ 108.2 & -109.6 \end{array}\right ) $$

s = tf('s','TimeUnit','minutes');
G = [87.8 -86.4 ; 108.2 -109.6]/(75*s+1);
G.InputName = {'L','V'};
G.OutputName = {'yD','yB'};

Control Architecture

The control objectives are as follows:

  • Independent control of the tops and bottoms concentrations by ensuring that a change in the tops setpoint Dsp has little impact on the bottoms concentration B and vice versa

  • Response time of about 15 minutes

  • Fast rejection of input disturbances affecting the effective reflux L and boilup V

To achieve these objectives we use the control architecture shown below. This architecture consists of a static decoupling matrix DM in series with two PI controllers for the reflux L and boilup V.


Controller Tuning in Simulink with LOOPTUNE

The looptune command provides a quick way to tune MIMO feedback loops. When the control system is modeled in Simulink, you just specify the tuned blocks, the control and measurement signals, and the desired bandwidth, and looptune automatically sets up the problem and tunes the controller parameters. looptune shapes the open-loop response to provide integral action, roll-off, and adequate MIMO stability margins.

Use the slTuner interface to specify the tuned blocks, the controller I/Os, and signals of interest for closed-loop validation.

ST0 = slTuner('rct_distillation',{'PI_L','PI_V','DM'});

% Signals of interest

Use TuningGoal objects to express the design requirements. Set the control bandwidth by using [0.1,0.5] as gain crossover band for the open-loop response.

wc = [0.1,0.5];

Specify that each loop should respond to a step command in about 15 minutes with minimum cross-coupling.

TR = TuningGoal.Tracking('r','y',15);

Also specify how the feedback loop should reject step disturbances at the plant input. The response should be well damped, settle in less than 20 minutes, and not exceed 4 in amplitude.

DR = TuningGoal.StepRejection({'dL','dV'},'y',4,20);

Next use looptune to tune the controller blocks PI_L, PI_V, and DM subject to these requirements.

Controls = {'L','V'};
Measurements = 'y';
[ST,gam,Info] = looptune(ST0,Controls,Measurements,wc,TR,DR);
Final: Peak gain = 1, Iterations = 45
Achieved target gain value TargetGain=1.

The final value is near 1 which indicates that all requirements were met. Use loopview to check the resulting design. The responses should stay outside the shaded areas.


Use getIOTransfer to access and plot the closed-loop responses from reference and disturbance to the tops and bottoms concentrations. The tuned responses show a good compromise between tracking and disturbance rejection.

Ttrack = getIOTransfer(ST,'r','y');
step(Ttrack,40), grid, title('Setpoint tracking')

Treject = getIOTransfer(ST,{'dV','dL'},'y');
step(Treject,40), grid, title('Disturbance rejection')

Equivalent Workflow in MATLAB

If you do not have a Simulink model of the control system, you can use LTI objects and Control Design blocks to create a MATLAB representation of the following block diagram.

Figure 2: Block Diagram of Control System

First parameterize the tunable elements using Control Design blocks. Use the ltiblock.gain block to parameterize DM:

DM = ltiblock.gain('Decoupler',eye(2));

This creates a 2x2 static gain with four tunable parameters. Similarly, use the block to parameterize the two PI controllers:

PI_L ='PI_L','pi');  PI_L.TimeUnit = 'minutes';
PI_V ='PI_V','pi');  PI_V.TimeUnit = 'minutes';

At this point, the tunable elements are over-parameterized because multiplying DM by two and dividing the PI coefficients by two does not change the overall controller. To eliminate redundant parameters, normalize the PI controllers by fixing their proportional gain Kp to 1:

PI_L.Kp.Value = 1;  PI_L.Kp.Free = false;
PI_V.Kp.Value = 1;  PI_V.Kp.Free = false;

Next construct a model C0 of the controller $C$ in Figure 2.

C0 = blkdiag(PI_L,PI_V) * DM * [eye(2) -eye(2)];

% Note: I/O names should be consistent with those of G
C0.InputName = {'Dsp','Bsp','yD','yB'};
C0.OutputName = {'L','V'};

Now tune the controller parameters with looptune as done previously.

% Crossover band
wc = [0.1,0.5];

% Tracking requirement
TR = TuningGoal.Tracking({'Dsp','Bsp'},{'yD','yB'},15);

% Disturbance rejection requirement
DR = TuningGoal.StepRejection({'L','V'},{'yD','yB'},4,20);

[~,C] = looptune(G,C0,wc,TR,DR);
Final: Peak gain = 1, Iterations = 70
Achieved target gain value TargetGain=1.

To validate the design, close the loop with the tuned compensator C and simulate the step responses for setpoint tracking and disturbance rejection. Also compare the open- and closed-loop disturbance rejection characteristics in the frequency domain.

Tcl = connect(G,C,{'Dsp','Bsp','L','V'},{'yD','yB'});

Ttrack = Tcl(:,[1 2]);
step(Ttrack,40), grid, title('Setpoint tracking')

Treject = Tcl(:,[3 4]);
Treject.InputName = {'dL','dV'};
step(Treject,40), grid, title('Disturbance rejection')

clf, sigma(G,Treject), grid
title('Rejection of input disturbances')

The results are similar to those obtained in Simulink.

Was this topic helpful?