Main Content

musynperf

Robust H∞ performance optimized by musyn

collapse all in page

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.

[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

γ=maxΔmaxωσmax(CLP(jω)).

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.

example

[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

Open Live Script

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 H∞ 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 H∞ 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 H∞ 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

See Also

| | | | | | |

Topics