# Documentation

### This is machine translation

Translated by
Mouseover text to see original. Click the button below to return to the English verison of the page.

# robustperf

(Not recommended) Robust performance margin of uncertain multivariable system

`robustperf` is not recommended. Use `robgain` instead.

## Syntax

```perfmarg = robustperf(usys)
[perfmarg,wcu,report,info] = robustperf(usys)
[perfmarg,wcu,report,info] = robustperf(usys,opt)
```

## Description

The performance of a nominally stable uncertain system model will generally degrade for specific values of its uncertain elements. `robustperf`, largely included for historical purposes, computes the robust performance margin, which is one measure of the level of degradation brought on by the modeled uncertainty.

As with other uncertain-system analysis tools, only bounds on the performance margin are computed. The exact robust performance margin is guaranteed to lie between these upper and lower bounds.

The computation used in `robustperf` is a frequency-domain calculation. Coupled with stability of the nominal system, this frequency domain calculation determines robust performance of `usys`. If the input system `usys` is a `ufrd`, then the analysis is performed on the frequency grid within the `ufrd`. Note that the stability of the nominal system is not verified by the computation. If the input system sys is a `uss`, then the stability of the nominal system is first checked, an appropriate frequency grid is generated (automatically), and the analysis performed on that frequency grid. In all discussion that follows, N denotes the number of points in the frequency grid.

### Basic Syntax

Suppose `usys` is a `ufrd` or `uss` with M uncertain elements. The results of

```[perfmarg,perfmargunc,Report] = robustperf(usys) ```

are such that `perfmarg` is a structure with the following fields:

Field

Description

`LowerBound`

Lower bound on robust performance margin, positive scalar.

`UpperBound`

Upper bound on robust performance margin, positive scalar.

`CriticalFrequency`

The value of frequency at which the performance degradation curve crosses the y = 1/x curve. See Robustness and Worst-Case Analysis.

`perfmargunc` is a `struct` of values of uncertain elements associated with the intersection of the performance degradation curve and the y = 1/x curve. See Robustness and Worst-Case Analysis. There are M field names, which are the names of uncertain elements of `usys`.

`Report` is a text description of the robust performance analysis results.

If `usys` is an array of uncertain models, the outputs are struct arrays whose entries correspond to each model in the array.

## Examples

Create a plant with a nominal model of an integrator, and include additive unmodeled dynamics uncertainty of a level of 0.4 (this corresponds to 100% model uncertainty at 2.5 rads/s).

```P = tf(1,[1 0]) + ultidyn('delta',[1 1],'bound',0.4); ```

Design a “proportional” controller K that puts the nominal closed-loop bandwidth at 0.8 rad/s. Roll off K at a frequency 25 times the nominal closed-loop bandwidth. Form the closed-loop sensitivity function.

```BW = 0.8; K = tf(BW,[1/(25*BW) 1]); S = feedback(1,P*K); ```

Assess the performance margin of the closed-loop sensitivity function. Because the nominal gain of the sensitivity function is 1, and the performance degradation curve is monotonically increasing (see Robustness and Worst-Case Analysis), the performance margin should be less than 1.

```[perfmargin,punc] = robustperf(S); perfmargin perfmargin = UpperBound: 7.4305e-001 LowerBound: 7.4305e-001 CriticalFrequency: 5.3096e+000 ```

You can verify that the upper bound of the performance margin corresponds to a point on or above the y=1/x curve. First, compute the normalized size of the value of the uncertain element, and check that this agrees with the upper bound.

```nsize = actual2normalized(S.Uncertainty.delta, punc.delta) nsize = perfmargin.UpperBound ans = 7.4305e-001 ```

Compute the system gain with that value substituted, and verify that the product of the normalized size and the system gain is greater than or equal to 1.

```gain = norm(usubs(S,punc),inf,.00001); nsize*gain ans = 1.0000e+000 ```

Finally, as a sanity check, verify that the robust performance margin is less than the robust stability margin.

```[stabmargin] = robuststab(S); stabmargin stabmargin = UpperBound: 3.1251e+000 LowerBound: 3.1251e+000 DestabilizingFrequency: 4.0862e+000 ```

While the robust stability margin is easy to describe (poles migrating from stable region into unstable region), describing the robust performance margin is less elementary. See the diagrams and figures in Robustness and Worst-Case Analysis. Rather than finding values for uncertain elements that lead to instability, the analysis finds values of uncertain elements “corresponding to the intersection point of the performance degradation curve with a y=1/x hyperbola.” This characterization, mentioned above in the description of `perfmarg.CriticalFrequency` and `perfmargunc`, is used often in the descriptions below.

### Basic Syntax with Fourth Output Argument

A fourth output argument yields more specialized information, including sensitivities and frequency-by-frequency information.

```[perfmarg,perfmargunc,Report,Info] = robustperf(usys) ```

In addition to the first 3 output arguments, described previously, `Info` is a structure with the following fields:

Field

Description

`Sensitivity`

A `struct` with M fields, field names are names of uncertain elements of `usys`. Values of fields are positive and contain the local sensitivity of the overall Stability Margin to that element's uncertainty range. For instance, a value of 25 indicates that if the uncertainty range is enlarged by 8%, then the stability margin should drop by about 2% (25% of 8). If the `Sensitivity` property of the `robustperfOptions` object is `'off'`, the values are set to `NaN`.

`Frequency`

N-by-1 frequency vector associated with analysis.

`BadUncertainValues`

N-by-1 struct array containing the worst uncertain element values at each frequency.

`MussvBnds`

A 1-by-2 `frd`, with upper and lower bounds from `mussv`. The (1,1) entry is the µ-upper bound (corresponds to `perfmarg.LowerBound`) and the (1,2) entry is the µ-lower bound (for `perfmarg.UpperBound`).

`MussvInfo`

Structure of compressed data from `mussv`.

Use `robustperfOptions` to specify additional options for the `robustperf` computation. For example, you can control what is displayed during the computation, turn the sensitivity computation on or off, set the step size in the sensitivity computation, or control the option argument used in the underlying call to `mussv`. For example, you can turn the display on and turn off the sensitivity by executing

```opt = robustperfOptions('Sensitivity','off','Display','on'); [PerfMarg,Destabunc,Report,Info] = robustperf(usys,opt) ```

See the `robustperfOptions` reference page for more information about available options.

## Limitations

Because the calculation is carried out with a frequency gridding, it is possible (likely) that the true critical frequency is missing from the frequency vector used in the analysis. This is similar to the problem in `robuststab`. However, in comparing to `robuststab`, the problem in `robustperf` is less acute. The robust performance margin, considered a function of problem data and frequency, is typically a continuous function (unlike the robust stability margin, described in Getting Reliable Estimates of Robustness Margins). Hence, in robust performance margin calculations, increasing the density of the frequency grid will always increase the accuracy of the answers, and in the limit, answers arbitrarily close to the actual answers are obtainable with finite frequency grids.

## Algorithms

A rigorous robust performance analysis consists of two steps:

1. Verify that the nominal system is stable.

2. Robust performance analysis on an augmented system.

The algorithm in `robustperf` follows this in spirit, with the following limitations:

• If `usys` is a `uss` object, then `robustperf` explicitly checks the stability of the nominal value. However, if `usys` is a `ufrd` model, `robustperf` instead assumes that the nominal value is stable, and does not perform this check.

• The exact performance margin is guaranteed to be no larger than `UpperBound` (some uncertain elements associated with this magnitude cause instability – one instance is returned in the structure `perfmargunc`). The instability created by `perfmargunc` occurs at the frequency value in `CriticalFrequency`.

• Similarly, the exact performance margin is guaranteed to be no smaller than `LowerBound`.