Typically, gain-scheduled control systems in Simulink^{®} use lookup tables or MATLAB Function blocks to specify gain
values as a function of the scheduling variables. For tuning, you replace these blocks by
parametric gain surfaces. A *parametric gain surface* is a basis-function
expansion whose coefficients are tunable. For example, you can model a time-varying gain
*k*(*t*) as a cubic polynomial in
*t*:

*k*(*t*) =
*k*_{0} +
*k*_{1}*t* +
*k*_{2}*t*^{2}
+
*k*_{3}*t*^{3}.

Here,
*k*_{0},...,*k*_{3}
are tunable coefficients. When you parameterize scheduled gains in this way,
`systune`

can tune the gain-surface coefficients to meet your control
objectives at a representative set of operating conditions. For applications where gains vary
smoothly with the scheduling variables, this approach provides explicit formulas for the
gains, which the software can write directly to MATLAB Function blocks. When
you use lookup tables, this approach lets you tune a few coefficients rather than many
individual lookup-table entries, drastically reducing the number of parameters and ensuring
smooth transitions between operating points.

In a gain-scheduled controller, the scheduled gains are functions of the scheduling
variables, *σ*. For example, a gain-scheduled PI controller has the
form:

$$C\left(s,\sigma \right)={K}_{p}\left(\sigma \right)+\frac{{K}_{i}\left(\sigma \right)}{s}.$$

Tuning this controller requires determining the functional forms
*K _{p}*(

In the first approach, you choose a collection of design points, *σ*,
and tune the gains *K _{p}* and

Alternatively, you can model the gains as smooth functions of *σ*, but
restrict the generality of such functions by using specific basis function expansions. For
example, suppose *σ* is a scalar variable. You can model
*K _{p}*(

$${K}_{p}\left(\sigma \right)={k}_{0}+{k}_{1}\sigma +{k}_{2}{\sigma}^{2}.$$

After tuning, this parametric gain might have a profile such as the following (the
specific shape of the curve depends on the tuned coefficient values and range of
*σ*):

Or, suppose that *σ* consists of two scheduling variables,
*α* and *V*. Then, you can model
*K _{p}*(

$${K}_{p}\left(\alpha ,V\right)={k}_{0}+{k}_{1}\alpha +{k}_{2}V+{k}_{3}\alpha V.$$

After tuning, this parametric gain might have a profile such as the following. Here too,
the specific shape of the curve depends on the tuned coefficient values and ranges of
*σ* values:

For tuning gain schedules with `systune`

, you use a
*parametric gain surface* that is a particular expansion of the gain
in basis functions of *σ*:

$$K\left(\sigma \right)={K}_{0}+{K}_{1}{F}_{1}\left(n\left(\sigma \right)\right)+\dots +{K}_{M}{F}_{M}\left(n\left(\sigma \right)\right).$$

The basis functions
*F*_{1},...,*F _{M}*
are user-selected and fixed. These functions operate on

Use the `tunableSurface`

command to construct a
tunable model of a gain surface sampled over a grid of design points (*σ*
values). For example, consider the gain with bilinear dependence on two scheduling
variables, *α* and *V*:

$${K}_{p}\left(\alpha ,V\right)={K}_{0}+{K}_{1}\alpha +{K}_{2}V+{K}_{3}\alpha V.$$

Suppose that *α* is an angle of incidence that ranges from 0° to 15°,
and *V* is a speed that ranges from 300 m/s to 700 m/s. Create a grid of
design points that span these ranges. These design points must match the parameter values at
which you sample your varying or nonlinear plant. (See
Plant Models for Gain-Scheduled Controller Tuning.)

[alpha,V] = ndgrid(0:5:15,300:100:700); domain = struct('alpha',alpha,'V',V);

Specify the basis functions for the parameterization of this surface,
*α*, *V*, and *αV*. The
`tunableSurface`

command expects the basis functions to be arranged as
a vector of functions of two input variables. You can use an anonymous function to express
the basis functions.

shapefcn = @(alpha,V)[alpha,V,alpha*V];

Alternatively, use `polyBasis`

, `fourierBasis`

, or `ndBasis`

to generate basis functions of as
many scheduling variables as you need.

Create the tunable surface using the design points and basis functions.

`Kp = tunableSurface('Kp',1,domain,shapefcn);`

`Kp`

is a tunable model of the gain surface.
`tunableSurface`

parameterizes the surface as:

$${K}_{p}\left(\alpha ,V\right)={\overline{K}}_{0}+{\overline{K}}_{1}\overline{\alpha}+{\overline{K}}_{2}\overline{V}+{\overline{K}}_{3}\overline{\alpha}\overline{V},$$

where

$$\overline{\alpha}=\frac{\alpha -7.5}{7.5},\text{\hspace{1em}}\overline{V}=\frac{V-500}{200}.$$

The surface is expressed in terms of the normalized variables, $$\overline{\alpha},\overline{V}\in {\left[-1,1\right]}^{2}$$ rather than in terms of *α* and *V*.
This normalization, which `tunableSurface`

performs by default, improves
the conditioning of the optimization performed by `systune`

. If needed,
you can change the default scaling and normalization. (See `tunableSurface`

).

The second input argument to `tunableSurface`

specifies the initial
value of the constant coefficient, *K*_{0}. By default,
*K*_{0} is the gain when all the scheduling variables
are at the center of their ranges. `tunableSurface`

takes the I/O
dimensions of the gain surface from *K*_{0}. Therefore,
you can create array-valued tunable gains by providing an array for that input.

`Karr = tunableSurface('Karr',ones(2),domain,shapefcn);`

`Karr`

is a 2-by-2 matrix in which each entry is a bilinear function of
the scheduling variables with independent coefficients.

This example shows how to model a scalar gain *K* with a bilinear dependence on two scheduling variables. You do so by creating a grid of design points representing the independent dependence of the two variables.

Suppose that the first variable *α* is an angle of incidence that ranges from 0 to 15 degrees, and the second variable *V* is a speed that ranges from 300 to 600 m/s. By default, the normalized variables are:

$$x=\frac{\alpha -7.5}{7.5},\phantom{\rule{1em}{0ex}}y=\frac{V-450}{150}.$$

The gain surface is modeled as:

$$K\left(\alpha ,V\right)={K}_{0}+{K}_{1}x+{K}_{2}y+{K}_{3}xy,$$

where $${K}_{0},...,{K}_{3}$$ are the tunable parameters.

Create a grid of design points, (*α*,*V*), that are linearly spaced in *α* and *V*. These design points are the scheduling-variable values used for tuning the gain-surface coefficients. They must correspond to parameter values at which you have sampled the plant.

[alpha,V] = ndgrid(0:3:15,300:50:600);

These arrays, `alpha`

and `V`

, represent the independent variation of the two scheduling variables, each across its full range. Put them into a structure to define the design points for the tunable surface.

domain = struct('alpha',alpha,'V',V);

Create the basis functions that describe the bilinear expansion.

`shapefcn = @(x,y) [x,y,x*y]; % or use polyBasis('canonical',1,2)`

In the array returned by `shapefcn`

, the basis functions are:

$$\begin{array}{c}{F}_{1}\left(x,y\right)=x\\ {F}_{2}\left(x,y\right)=y\\ {F}_{3}\left(x,y\right)=xy.\end{array}$$

Create the tunable gain surface.

`K = tunableSurface('K',1,domain,shapefcn);`

You can use the tunable surface as the parameterization for a lookup table block or a MATLAB Function block in a Simulink model. Or, use model interconnection commands to incorporate it as a tunable element in a control system modeled in MATLAB. After you tune the coefficients, you can examine the resulting gain surface using the `viewSurf`

command. For this example, instead of tuning, manually set the coefficients to non-zero values and view the resulting gain.

Ktuned = setData(K,[100,28,40,10]); viewSurf(Ktuned)

`viewSurf`

displays the gain surface as a function of the scheduling variables, for the ranges of values specified by `domain`

and stored in the `SamplingGrid`

property of the gain surface.

In your Simulink model, you model gain schedules using lookup table blocks, MATLAB
Function blocks, or Matrix Interpolation blocks, as described in
Model Gain-Scheduled Control Systems in Simulink. To tune these
gain surfaces, use `tunableSurface`

to create a gain surface for each
block. In the `slTuner`

interface to the model, designate each gain
schedule as a block to tune, and set its parameterization to the corresponding gain surface.
For instance, the `rct_CSTR`

model includes a gain-scheduled PI controller,
the `Concentration controller`

subsystem, in which the gains
`Kp`

and `Ki`

vary with the scheduling variable
`Cr`

.

To tune the lookup tables `Kp`

and `Ki`

, create a
tunable surface for each one. Suppose that `CrEQ`

is the vector of design
points, and that you expect the gains to vary quadratically with
`Cr`

.

TuningGrid = struct('Cr',CrEQ); ShapeFcn = @(Cr) [Cr , Cr^2]; Kp = tunableSurface('Kp',0,TuningGrid,ShapeFcn); Ki = tunableSurface('Ki',-2,TuningGrid,ShapeFcn);

Suppose that you have an array `Gd`

of linearizations of the plant
subsystem, `CSTR`

, at each of the design points in `CrEQ`

. (See
Plant Models for Gain-Scheduled Controller Tuning). Create an
`slTuner`

interface that substitutes this array for the plant subsystem
and designates the two lookup-table blocks for tuning.

BlockSubs = struct('Name','rct_CSTR/CSTR','Value',Gd); ST0 = slTuner('rct_CSTR',{'Kp','Ki'},BlockSubs);

Finally, use the tunable surfaces to parameterize the lookup tables.

ST0.setBlockParam('Kp',Kp); ST0.setBlockParam('Ki',Ki);

When you tune `STO`

, `systune`

tunes the
coefficients of the tunable surfaces `Kp`

and `Ki`

, so
that each tunable surface represents the tuned relationship between `Cr`

and the gain. When you write the tuned values back to the block for validation,
`setBlockParam`

automatically generates tuned lookup-table data by
evaluating the tunable surfaces at the breakpoints you specify in the corresponding blocks.

For more details about this example, see Gain-Scheduled Control of a Chemical Reactor.

For a control system modeled in MATLAB^{®}, use tunable surfaces to construct more complex gain-scheduled control
elements, such as gain-scheduled PID controllers, filters, or state-space controllers. For
example, suppose that you create two gain surfaces `Kp`

and
`Ki`

using `tunableSurface`

. The following command
constructs a tunable gain-scheduled PI controller.

C0 = pid(Kp,Ki);

Similarly, suppose that you create four matrix-valued gain surfaces
`A`

, `B`

, `C`

, `D`

. The
following command constructs a tunable gain-scheduled state-space controller.

C1 = ss(A,B,C,D);

You then incorporate the gain-scheduled controller into a generalized model of your
entire control system. For example, suppose `G`

is an array of models of
your plant sampled at the design points that are specified in `Kp`

and
`Ki`

. Then, the following command builds a tunable model of a
gain-scheduled single-loop PID control system.

T0 = feedback(G*C0,1);

When you interconnect a tunable surface with other LTI models, the resulting model is an
array of tunable generalized `genss`

models. The design points in the
tunable surface determine the dimensions of the array. Thus, each entry in the array
represents the system at the corresponding scheduling variable value. The
`SamplingGrid`

property of the array stores those design points.

T0 = feedback(G*Kp,1)

T0 = 4x5 array of generalized continuous-time state-space models. Each model has 1 outputs, 1 inputs, 3 states, and the following blocks: Kp: Parametric 1x4 matrix, 1 occurrences. Type "ss(T0)" to see the current value, "get(T0)" to see all properties, and "T0.Blocks" to interact with the blocks.

The resulting generalized model has tunable blocks corresponding to the gain surfaces
used to create the model. In this example, the system has one gain surface,
`Kp`

, which has the four tunable coefficients corresponding to
*K*_{0},
*K*_{1}, *K*_{2},
and *K*_{3}. Therefore, the tunable block is a
vector-valued `realp`

parameter with four entries.

When you tune the control system with `systune`

, the software tunes
the coefficients for each of the design points specified in the tunable surface.

For an example illustrating the entire workflow in MATLAB, see the section "Controller Tuning in MATLAB" in Gain-Scheduled Control of a Chemical Reactor.