## Documentation |

This example shows how to use the `slLinearizer` interface to batch linearize a Simulink model. You vary model parameter values and obtain multiple open- and closed-loop transfer functions from the model.

You can perform the same analysis using the `linearize` command. However, when you want to obtain multiple open- and closed-loop transfer functions, especially for a large-scale model, `slLinearizer` can be more efficient.

The `scdcascade` model contains a pair of cascaded feedback control loops. Each loop includes a PI controller. The plant models, `G1` (outer loop) and `G2` (inner loop), are LTI models.

Use the `slLinearizer` interface to initially analyze the inner-loop dynamics. Then, analyze the outer-loop dynamics.

```
mdl = 'scdcascade';
open_system(mdl);
```

**Create slLinearizer Interface for scdcascade**

sllin = slLinearizer(mdl)

slLinearizer linearization interface for "scdcascade": No analysis points. Use the addPoint command to add new points. No permanent openings. Use the addOpening command to add new permanent openings. Properties with dot notation get/set access: Parameters : [] OperatingPoints : [] (model initial condition will be used.) BlockSubstitutions : [] Options : [1x1 linearize.LinearizeOptions]

**Vary Inner-Loop Controller Gains**

For inner-loop analysis, vary the gains of the inner-loop PI controller block, `C2`. Vary the proportional gain (`Kp2`) and integral gain (`Ki2`) in the 15% range.

Kp2_range = linspace(Kp2*0.85,Kp2*1.15,6); Ki2_range = linspace(Ki2*0.85,Ki2*1.15,4); [Kp2_grid, Ki2_grid] = ndgrid(Kp2_range,Ki2_range); params(1).Name = 'Kp2'; params(1).Value = Kp2_grid; params(2).Name = 'Ki2'; params(2).Value = Ki2_grid; sllin.Parameters = params;

`Kp2_range` and `Ki2_range` specify the sample values for the `Kp2` and `Ki2` parameters. To obtain a transfer function for each combination of `Kp2` and `Ki2`, you use `ndgrid` and construct a 6x4 parameter grid, with grid arrays `Kp2_grid` and `Ki2_grid`. You configure the `Parameters` property of `sllin` with the structure `params`. This structure specifies the parameters to be varied and their grid arrays.

**Analyze Overall Closed-Loop Transfer Function for Inner Loop**

The overall closed-loop transfer function for the inner loop, with the outer loop open, is equal to the transfer function from `u1` to `y2`. To eliminate the effects of the outer loop, break the loop at `e1`, `y1m`, or `y1`. For this example, break the loop at `e1`.

Add `u1` and `y2` as analysis points, and `e1` as a permanent opening of `sllin`.

addPoint(sllin,{'y2','u1'}); addOpening(sllin,'e1');

Obtain the transfer function from `u1` to `y2`.

r2yi = getIOTransfer(sllin,'u1','y2');

`r2yi`, a 6x4 `ss` model array, contains the transfer function for each specified parameter combination. The software uses the model initial conditions as the linearization operating point.

Because `e1` is a permanent opening of `sllin`, `r2yi` does not include the effects of the outer loop.

Plot the step response for `r2yi`.

stepplot(r2yi);

The step response for all the models varies in the 10% range. The settling time for most models is less than 1.5 seconds.

**Analyze Inner-Loop Transfer Function at Plant Output**

Obtain the inner-loop transfer function at `y2`, with the outer loop open at `e1`.

```
Li = getLoopTransfer(sllin,'y2',-1);
```

Because the software assumes positive feedback by default and `scdcascade` uses negative feedback, you specify the feedback sign using the third input argument. Now, `Li = -G2C2`.

Plot the bode response for `Li`.

bodeplot(Li);

The magnitude plot for all the models varies in the 3dB range. The phase plot shows the most variation, approximately 20 degrees, in the [1 10] rad/s interval.

**Vary Outer-Loop Controller Gains**

For outer-loop analysis, vary the gains of the outer-loop PI controller block, `C1`. Vary the proportional gain (`Kp1`) and integral gain (`Ki1`) in the 20% range.

Kp1_range = linspace(Kp1*0.8,Kp1*1.2,6); Ki1_range = linspace(Ki1*0.8,Ki1*1.2,4); [Kp1_grid, Ki1_grid] = ndgrid(Kp1_range,Ki1_range); params(1).Name = 'Kp1'; params(1).Value = Kp1_grid; params(2).Name = 'Ki1'; params(2).Value = Ki1_grid; sllin.Parameters = params;

Similar to the workflow for configuring the parameter grid for inner-loop analysis, you create the structure, `params`, that specifies a 6x4 parameter grid. You reconfigure `sllin.Parameters` to use the new parameter grid. `sllin` now uses the default values for `Ki2` and `Kp2`.

**Analyze Closed-Loop Transfer Function from Reference To Plant Output**

Remove `e1` from the list of permanent openings for `sllin` before proceeding with outer-loop analysis.

```
removeOpening(sllin,'e1');
```

To obtain the closed-loop transfer function from the reference signal, `r`, to the plant output, `y1m`, add `r` and `y1m` as analysis points to `sllin`.

addPoint(sllin,{'r','y1m'});

Obtain the transfer function from `r` to `y1m`.

r2yo = getIOTransfer(sllin,'r','y1m');

Plot the step response for `r2yo`.

stepplot(r2yo);

The step response in underdamped for all the models.

**Analyze Outer-Loop Sensitivity at Plant Output**

To obtain the outer-loop sensitivity at the plant output, use `y1` as the analysis point. Add `y1` as an analysis point to `sllin`.

```
addPoint(sllin,'y1');
```

Obtain the outer-loop sensitivity at `y1`.

```
So = getSensitivity(sllin,'y1');
```

Plot the step response of `So`.

stepplot(So);

This plot indicates that it takes approximately 15 seconds to reject a step disturbance at the plant output, `y1`.

Close the Simulink model

bdclose(mdl);

Was this topic helpful?