# musynperf

Robust H performance optimized by `musyn`

Since R2019b

## Syntax

``````[gamma,wcu] = musynperf(clp)``````
``````[gamma,wcu] = musynperf(clp,w)``````
``````[gamma,wcu] = musynperf(___,opts)``````
``````[gamma,wcu,info] = musynperf(___)``````

## Description

The robust H performance of an uncertain system is the smallest value γ such that the I/O gain of the system stays below γ for all modeled uncertainty up to size 1/γ (in normalized units). The `musyn` function synthesizes a robust controller by minimizing this quantity for the closed-loop system over all possible choices of controller. `musynperf` computes this quantity for a specified uncertain model. For a detailed discussion of robust H performance and how it is computed, see Robust Performance Measure for Mu Synthesis.

example

``````[gamma,wcu] = musynperf(clp)``` calculates the robust H∞ performance for an uncertain closed-loop system `clp`. The robust H∞ performance is the smallest value γ for which the peak I/O gain stays below γ for all modeled uncertainty up to 1/γ, in normalized units. For example, a value of γ = 1.125 implies the following:The I/O gain of `clp` remains less than 1.125 as long as the uncertain elements stay within 0.8 normalized units of their nominal values. In other words, for uncertain element values within 0.8 normalized units, the largest possible H∞ norm is 1.125.For some perturbation of size 0.8 normalized units, the peak I/O gain is 1.125.The peak I/O gain is the maximum I/O gain over all inputs, which is also the peak of the largest singular value over all frequencies and uncertainties. In other words, if Δ represents all possible values of the uncertain parameters in the closed-loop transfer function CLP(jω), then$\gamma =\underset{\Delta }{\mathrm{max}}\underset{\omega }{\mathrm{max}}{\sigma }_{max}\left(CLP\left(j\omega \right)\right).$The output structure `gamma` contains upper and lower bounds on the robust H∞ performance and the critical frequency at which the I/O gain of `clp` reaches the lower bound. The structure `wcu` contains the uncertain-element values that drive the peak I/O gain to the lower bound.```
``````[gamma,wcu] = musynperf(clp,w)``` computes the robust H∞ performance at the frequencies specified by `w`.If `w` is a cell array of the form `{wmin,wmax}`, then `musynperf` restricts the computation to the interval between `wmin` and `wmax`.If `w` is a vector of frequencies, then `musynperf` computes the H∞ performance at the specified frequencies only.```
``````[gamma,wcu] = musynperf(___,opts)``` specifies additional options for the computation. Use `robOptions` to create `opts`. You can use this syntax with any of the previous input-argument combinations.```
``````[gamma,wcu,info] = musynperf(___)``` returns a structure with additional information about the H∞ performance values and the perturbations that drive the I/O gain to γ. See `info` for details about this structure. You can use this syntax with any of the previous input-argument combinations.```

## Examples

collapse all

When you use `musyn` to synthesize an unstructured robust controller, the resulting controller often is of higher order than is necessary to achieve the desired robust performance. One way to mitigate this problem is to perform model reduction, using `musynperf` to test the robust performance of the reduced-order controller.

Create an uncertain model of the control system described in the example "Robust Tuning of Fixed-Structure Controller" on the `musyn` reference page.

```G = tf(1,[1 -1]); Wu = 0.25*tf([1/2 1],[1/32 1]); InputUnc = ultidyn('InputUnc',[1 1]); Gpert = G*(1+InputUnc*Wu); Gpert.InputName = 'u'; Gpert.OutputName = 'y1'; Wp = makeweight(100,[1 0.5],0.25); Wp.InputName = 'y'; Wp.OutputName = 'e'; SumD = sumblk('y = y1 + d'); inputs = {'d','u'}; outputs = {'e','y'}; P = connect(Gpert,Wp,SumD,inputs,outputs); [K,CLperf] = musyn(P,1,1); ```
```D-K ITERATION SUMMARY: ----------------------------------------------------------------- Robust performance Fit order ----------------------------------------------------------------- Iter K Step Peak MU D Fit D 1 1.345 1.344 1.36 8 2 0.7923 0.7904 0.7961 4 3 0.6789 0.6789 0.6857 10 4 0.6572 0.6572 0.6598 8 5 0.6538 0.6538 0.6542 8 6 0.6532 0.6532 0.6533 8 Best achieved robust performance: 0.653 ```
`N = order(K)`
```N = 11 ```

`musyn` returns an 11th-order controller and the robust ${\mathit{H}}_{\infty }$ performance `CLperf` of the closed-loop system using that controller. The best achieved robust performance of about 0.65 is good, but the controller order is high. Compute reduced-order controllers for orders ranging from 1 to full order.

`Kred = reduce(K,1:N);`

Find the lowest-order controller `Klow` with performance no worse than 1.05*`CLperf`, or 5% degradation compared to the full-order controller.

```for k=1:N Klow = Kred(:,:,k); CL = lft(P,Klow); [gamma,~] = musynperf(CL); if gamma.UpperBound < 1.05*CLperf break end end order(Klow)```
```ans = 4 ```

To validate the reduced-order controller, examine the robust ${\mathit{H}}_{\infty }$ performance of the system using the simplified controller with that of the system using the full-order controller.

```CLPlow = lft(P,Klow); [gammalow,~] = musynperf(CLPlow); gammalow.UpperBound```
```ans = 0.6613 ```

The fourth-order controller achieves very similar robust ${\mathit{H}}_{\infty }$ performance to the 11th-order controller returned by `musyn`.

## Input Arguments

collapse all

Closed-loop uncertain system, specified as a `uss`, `ufrd`, `genss`, or `genfrd` model that contains uncertain elements. For `genss` or `genfrd` models, `musynperf` uses the current value of any tunable blocks and folds them into the known (not uncertain) part of the model.

Frequencies at which to compute robust H performance, specified as the cell array `{wmin,wmax}` or as a vector of frequency values.

• If `w` is a cell array of the form `{wmin,wmax}`, then the function computes the H performance at frequencies ranging between `wmin` and `wmax`.

• If `w` is a vector of frequencies, then the function computes the H performance at each specified frequency. For example, use `logspace` to generate a row vector with logarithmically spaced frequency values.

Specify frequencies in units of rad/`TimeUnit`, where `TimeUnit` is the `TimeUnit` property of the model.

Options for computation of robust H performance, specified as `robOptions` object. Use `robOptions` to create the options object. The available options include settings that let you:

• Extract frequency-dependent H performance values.

• Examine the sensitivity of the H performance to each uncertain element.

• Improve the results of the calculation by setting certain options for the underlying `mussv` calculation. In particular, setting the option `'MussvOptions'` to `'mN'` can reduce the gap between the lower bound and upper bound. `N` is the number of restarts.

For more information about all available options, see `robOptions`.

Example: `robOptions('Sensitivity','on','MussvOptions','m3')`

## Output Arguments

collapse all

Robust H performance and critical frequency, returned as a structure containing the following fields:

FieldDescription

`LowerBound`

Lower bound on the actual robust H performance γ, returned as a scalar value. The exact value of γ is guaranteed to be no smaller than `LowerBound`. In other words, some uncertain-element values of magnitude 1/`LowerBound` exist for which the I/O gain of `clp` reaches `LowerBound`. The function returns one such instance in `wcu`.

`UpperBound`

Upper bound on the actual robust H performance, returned as a scalar value. The exact value is guaranteed to be no larger than `UpperBound`. In other words, for all modeled uncertainty with normalized magnitude up to 1/`UpperBound`, the peak I/O gain of `clp` is less than `UpperBound`.

`CriticalFrequency`

Frequency at which the I/O gain reaches `LowerBound`, in rad/`TimeUnit`, where `TimeUnit` is the `TimeUnit` property of `clp`.

Use `uscale` or `normalized2actual` to convert the normalized uncertainty values 1/`LowerBound` or 1/`UpperBound` to actual deviations from nominal values.

Perturbations driving I/O gain to `gamma.LowerBound`, returned as a structure whose fields are the names of the uncertain elements of `clp`. Each field contains the actual value of the corresponding uncertain element. For example, if `clp` includes an uncertain matrix `M` and SISO uncertain dynamics `delta`, then `wcu.M` is a numeric matrix and `wcu.delta` is a SISO state-space model.

Use `usubs(clp,wcu)` to substitute these values for the uncertain elements in `clp` and obtain the corresponding dynamic system. This system has a peak gain of `gamma.LowerBound`.

Use `actual2normalized` to convert these actual uncertainty values to the normalized units in which 1/`gamma.LowerBound` or 1/`gamma.UpperBound` are expressed.

Additional information about the γ values, returned as a structure with the following fields.

FieldDescription

`Frequency`

Frequency points at which `musynperf` returns γ values, returned as a vector.

• If the `'VaryFrequency'` option of `robOptions` is `'off'`, then `info.Frequency` is the critical frequency, the frequency at which the I/O gain reaches `gamma.LowerBound`. If the smallest lower bound and the smallest upper bound on γ occur at different frequencies, then `info.Frequency` is a vector containing these two frequencies.

• If the `'VaryFrequency'` option of `robOptions` is `'on'`, then `info.Frequency` contains the frequencies selected by `musynperf`. These frequencies are guaranteed to include the frequency at which the peak gain occurs.

• If you specify a vector of frequencies `w` at which to compute γ, then ```info.Frequency = w```. When you specify a frequency vector, these frequencies are not guaranteed to include the frequency at which the peak gain occurs.

The `'VaryFrequency'` option is meaningful only for `uss` and `genss` models. `musynperf` ignores the option for `ufrd` and `genfrd` models.

`Bounds`

Lower and upper bounds on the actual γ values, returned as an array. `info.Bounds(:,1)` contains the lower bound at each corresponding frequency in `info.Frequency`, and `info.Bounds(:,2)` contains the corresponding upper bounds.

`WorstPerturbation`

Smallest perturbations at each frequency point in `info.Frequency`, returned as a structure array. The fields of `info.WorstPerturbation` are the names of the uncertain elements in `clp`. Each field contains the value of the corresponding element that drives the I/O gain to the corresponding lower bound at each frequency. For example, if `clp` includes an uncertain parameter `p` and SISO uncertain dynamics `delta`, then `info.WorstPerturbation.p` is a collection of numeric values and `info.WorstPerturbation.delta` is a collection of SISO state-space models.

`Sensitivity`

Sensitivity of γ to each uncertain element, returned as a structure when the `'Sensitivity'` option of `robOptions` is `'on'`. The fields of `info.Sensitivity` are the names of the uncertain elements in `clp`. Each field contains a percentage that measures how much the uncertainty in the corresponding element affects γ. For example, if `info.Sensitivity.p` is 50, then a given fractional change in the uncertainty range of `p` causes half as much fractional change in γ.

If the `'Sensitivity'` option of `robOptions` is `'off'` (the default setting), then `info.Sensitivity` is `NaN`.

## Version History

Introduced in R2019b