Improve Results of Mu Synthesis

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.

Mixed-μ Synthesis for Real Uncertainty

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-μ synthesis to see if it improves the performance relative to the controller you obtain without it.

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.

Reduce Controller Order

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:

Reduce Order of Returned Controller

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.

Lower Order Fixed-Structure 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.

Reduce Maximum Scaling Order

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.

Diagonal Scalings for Repeated Blocks

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.

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:

Use Diagonal Scalings

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.

Reduce Repetitions in the Plant

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.

Use 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.

See Also

|

Topics