Main Content

You can sometimes improve the results of robust controller synthesis with
`musyn`

. Even if the default options yield good results, by changing
certain options, you might be able to:

Find a controller that yields better robust performance.

Find a lower order controller that yields similar robust performance.

Consider trying several of the techniques described here to see whether the results you
obtain from `musyn`

can be improved.

By default, `musyn`

treats all uncertainties as complex
uncertainties, even those represented by real parameters. For `ureal`

blocks,
`musyn`

assumes that each real parameter has an imaginary part that can
vary by the same amount as the real part. This assumption simplifies the computation, but
yields a more conservative estimate of the robust performance of the system.

When you have real uncertainty, you can instead use
*mixed- μ synthesis*, which explicitly takes into
account the fact that some uncertain parameters are limited to real values. Try using
mixed-

To use mixed-*μ* synthesis, set the `'MixedMU'`

option
of `musynOptions`

to
`'on'`

. For an example that illustrates the benefit of
mixed-*μ* synthesis, see Control of a Spring-Mass-Damper System Using Mixed-Mu Synthesis.

Mixed-*μ* synthesis complicates the computation and can result in
higher order controllers. The techniques in Reduce Controller Order can help simplify the
resulting controller.

For unstructured controller design, `musyn`

can return relatively
high-order controllers. `musyn`

uses frequency-dependent scaling matrices
that are fit by rational functions. (See D-K Iteration Process.) The order required to
fit the scalings and the number of uncertain blocks in your system contribute to the order
of the final optimized controller. Therefore, after using `musyn`

for an
initial robust controller design, it can be useful to search for a lower order controller
that achieves similar robust performance. Among approaches to obtaining a lower order
controller, you can:

One technique is to use model-reduction commands to reduce the controller that
`musyn`

returns, and find the lowest order approximation that
achieves similar performance. For an example illustrating this approach, see the `musynperf`

reference page.

Even if the initial controller you obtain with `musyn`

is not
reducible in a way that preserves robust performance, a lower order controller that
achieves the same performance might exist. Consider trying the other techniques to see if
varying parameters of the `musyn`

computation can help you find such a
controller.

This approach takes advantage of the ability of `musyn`

to tune
fixed-structure controllers. Suppose that you use `musyn`

to design a
full-order, centralized controller `K`

for an uncertain plant
`P`

with `nmeas`

measurement signals and
`ncont`

control signals. You can create a fixed-order, tunable
state-space model of a lower order than `K`

, and use
`musyn`

again to tune the free parameters of that model. If the new
controller achieves robust performance close to that of the unstructured controller, try
again with an even lower order tunable state-space model. For instance, suppose
`K`

is a 10th-order controller returned by `musyn`

for the plant `P`

. The following commands create and tune a fifth-order
state-space controller by forming the closed-loop uncertain system with the tunable
controller and passing it to `musyn`

.

```
C0 = tunableSS('C0',5,nmeas,ncont);
CL0 = lft(P,C0);
[CL,CLperf,info] = musyn(CL0);
```

For a simple example, see Robust Tuning of Fixed-Structure Controller on the
`musyn`

reference page.

For each iteration, `musyn`

fits each entry in the
*D* and *G* scaling matrices by a rational function of
automatically selected order. The higher the order of these functions, the higher the
order of the resulting controller. By default, the maximum order is 5 for
*D* scaling, and 2 for the *G* scaling matrices. If
these defaults yield a controller with good robust performance, try lowering the maximum
order to see if `musyn`

returns a lower-order controller with similar
performance. To change the maximum order, use the `'FitOrder'`

option of
`musynOptions`

.

If your system has repeated uncertain parameters, you can restrict the
*D* and *G* scalings so they are diagonal, which can
result in a lower order unstructured controller. For more information, see Repeated Parameter Blocks.

An uncertain parameter can occur multiple times in a given model. For example, the
following code creates an uncertain state-space model that has two occurrences each of the
uncertain parameters `p1`

and `p2`

.

p1 = ureal('p1',10); p2 = ureal('p2',3); A = [-p1 p2;0 -p1]; B = [-p2; p2]; C = [1 0;1 1]; D = [0;0]; sys = ss(A,B,C,D)

sys = Uncertain continuous-time state-space model with 2 outputs, 1 inputs, 2 states. The model uncertainty consists of the following blocks: p1: Uncertain real, nominal = 10, variability = [-1,1], 2 occurrences p2: Uncertain real, nominal = 3, variability = [-1,1], 2 occurrences Type "sys.NominalValue" to see the nominal value, "get(sys)" to see all properties, and "sys.Uncertainty" to interact with the uncertain elements.

Multiple occurrences of uncertain parameters can increase the order of the rational fit
functions for the *D* and *G* scalings. Therefore, they
can increase the number of states in the controller returned by `musyn`

.
You can mitigate this effect of repeated parameters in several ways:

By default, `musyn`

by default uses full matrices for the
*D* and *G* scalings of repeated blocks. Full scaling
matrices can have frequency-dependent entries both on and off the diagonal. Fitting all of
these entries can result in high controller order. If `musyn`

instead
uses diagonal scaling, then fewer independent fit functions are needed, which can reduce
the controller order.

Diagonal scaling, is equivalent to treating each repeated block as an independent
instance of the uncertain parameter. Therefore, full scaling is less conservative and can
yield better robust performance. However, to reduce the controller order, you can try
diagonal scaling and see whether `musyn`

can still find an adequate
controller using the more conservative estimation of the *μ* upper
bound.

To specify diagonal scaling for repeated blocks, use the `'FullDG'`

option of `musynOptions`

.

Use `simplify`

to reduce the number of repeated
parameters in the plant before calling `musyn`

. The
`simplify`

command tries to remove redundant instances of uncertain
blocks.

`systune`

If you have more than about five repeated instances of an uncertain parameter and have
no dynamic uncertainty (no `ultidyn`

blocks), consider using
`systune`

instead of `musyn`

. The
`systune`

command tunes fixed-structure controller elements. It can
perform robust controller tuning without degradation caused by large numbers of repeated
blocks. For more information on ways to perform robust tuning with
`systune`

, see Robust Tuning Approaches.