# getCompSensitivity

Complementary sensitivity function from generalized model of control system

## Syntax

• `T = getCompSensitivity(CL,location)` example
• `T = getSensitivity(CL,location,opening)` example

## Description

example

````T = getCompSensitivity(CL,location)` returns the complementary sensitivity measured at the specified location for a generalized model of a control system.```

example

````T = getSensitivity(CL,location,opening)` specifies additional loop openings for the complementary sensitivity function calculation. Use an opening, for example, to calculate the complementary sensitivity function of an inner loop, with the outer loop open.If `opening` and `location` list the same point, the software opens the loop after adding the disturbance signal at the point.```

## Examples

collapse all

### Complementary Sensitivity Function at a Location

Compute the complementary sensitivity at the plant output, `X`.

Create a model of the system by specifying and connecting a numeric LTI plant model `G`, a tunable controller `C`, and the `AnalysisPoint` block `X`. Use the `AnalysisPoint` block to mark the location where you assess the complementary sensitivity (plant output in this example).

```G = tf([1],[1 5]); C = ltiblock.pid('C','p'); C.Kp.Value = 3; X = AnalysisPoint('X'); CL = feedback(G*C,X);```

`CL` is a `genss` model that represents the closed-loop response of the control system from r to y. The model contains the `AnalysisPoint` block, `X`, that identifies the analysis-point location.

Calculate the complementary sensitivity, T, at `X`.

```T = getCompSensitivity(CL,'X'); tf(T)```
```ans = From input "X" to output "X": -3 ----- s + 8 Continuous-time transfer function. ```

### Specify Additional Loop Opening for Complementary Sensitivity Function Calculation

Calculate the inner-loop sensitivity at the output of `G2`, with the outer loop open.

Create a model of the system by specifying and connecting the numeric plant models, tunable controllers, and `AnalysisPoint` blocks. `G1` and `G2` are plant models, `C1` and `C2` are tunable controllers, and `X1` and `X2` are `AnalysisPoint` blocks that mark potential loop-opening locations.

```G1 = tf(10,[1 10]); G2 = tf([1 2],[1 0.2 10]); C1 = ltiblock.pid('C','pi'); C2 = ltiblock.gain('G',1); X1 = AnalysisPoint('X1'); X2 = AnalysisPoint('X2'); CL = feedback(G1*feedback(G2*C2,X2)*C1,X1);```

Calculate the complementary sensitivity, T, at `X2`, with the outer loop open at `X1`.

```T = getCompSensitivity(CL,'X2','X1'); tf(T)```
```ans = From input "X2" to output "X2": -s - 2 ---------------- s^2 + 1.2 s + 12 Continuous-time transfer function.```

## Input Arguments

collapse all

### `CL` — Model of control systemgeneralized state-space model

Model of a control system, specified as a Generalized State-Space Model (`genss`).

Locations at which you can perform sensitivity analysis or open loops are marked by `AnalysisPoint` blocks in `CL`. Use `getPoints(CL)` to get the list of such locations.

### `location` — Locationstring | cell array of strings

Location at which you calculate the complementary sensitivity function, specified as a string or cell array of strings. To extract the complementary sensitivity function at multiple locations, use a cell array of strings.

Each string in `location` must match an analysis point in `CL`. Analysis points are marked using `AnalysisPoint` blocks. Use `getPoints(CL)` to get the list of available analysis points in `CL`.

Example: `'u'` or `{'u','y'}`

### `opening` — Additional loop openingstring | cell array of strings

Additional loop opening used to calculate the complementary sensitivity function, specified as a string or cell array of strings. To open the loop at multiple locations, use a cell array of strings.

Each string in `opening` must match an analysis point in `CL`. Analysis points are marked using `AnalysisPoint` blocks. Use `getPoints(CL)` to get the list of available analysis points in `CL`.

Use an opening, for example, to calculate the complementary sensitivity function of an inner loop, with the outer loop open.

If `opening` and `location` list the same point, the software opens the loop after adding the disturbance signal at the point.

Example: `'y_outer'` or `{'y_outer','y_outer2'}`

## Output Arguments

collapse all

### `T` — Complementary sensitivity functiongeneralized state-space model

Complementary sensitivity function of the control system, `T`, measured at `location`, returned as a Generalized State-Space Model (`genss`).

• If `location` specifies a single analysis point, then `T` is a SISO `genss` model.

• If `location` is a string specifying a vector signal, or a cell array identifying multiple analysis points, then `T` is a MIMO `genss` model.

collapse all

### Complementary Sensitivity

The complementary sensitivity function, T, at a point is the closed-loop transfer function around the feedback loop measured at the specified location. It is related to the open-loop transfer function, L, and the sensitivity function, S, at the same point as follows:

$T=\frac{L}{1-L}=S-1.$

Use `getLoopTransfer` and `getSensitivity` to compute L and S.

Consider the following model:

The complementary sensitivity, T, at `y` is defined as the transfer function from `dy` to `y`.

Observe that, in contrast to the sensitivity function, the disturbance, `dy`, is added after the measurement, `y`.

$\begin{array}{l}y=-GK\left(y+dy\right)\\ \to y=-GKy-GKdy\\ \to \left(I+GK\right)y=-GKdy\\ \to y=\underset{T}{\underbrace{-{\left(I+GK\right)}^{-1}GK}}dy.\end{array}$

Here, I is an identity matrix of the same size as GK. The complementary sensitivity transfer function at `y` is equal to `-1` times the closed-loop transfer function from `r` to `y`.

Complementary sensitivity at multiple locations, for example, `u` and `y`, is defined as the MIMO transfer function from the disturbances to measurements:

$T=\left[\begin{array}{cc}{T}_{du\to u}& {T}_{dy\to u}\\ {T}_{du\to y}& {T}_{dy\to y}\end{array}\right].$