dksynperf

(Not recommended) Robust H performance optimized by dksyn

dksynperf is not recommended. Use musynperf instead. For more information, see Compatibility Considerations.

Description

The robust H performance (or robust H norm) of an uncertain closed-loop 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 dksyn function synthesizes a robust controller by minimizing this quantity over all possible choices of controller. dksynperf computes this quantity for a specified uncertain model.

example

[gamma,wcu] = dksynperf(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.

  • There is a perturbation of size 0.8 normalized units that drives the peak I/O gain to 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(), 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.

[gamma,wcu] = dksynperf(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 dksynperf restricts the computation to the interval between wmin and wmax.

  • If w is a vector of frequencies, then dksynperf computes the H performance at the specified frequencies only.

[gamma,wcu] = dksynperf(___,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] = dksynperf(___) 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 dksyn 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 dksynperf to test the robust performance of the reduced-order controller.

Synthesize a controller for the system described in the dksyn example.

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); 
Wp = tf([1/4 0.6],[1 0.006]);
P = [Wp; 1 ]*[1 Gpert]; 

[K,clp,clperf] = dksyn(P,1,1); 
N = order(K)
N = 7

dksyn returns a 7th-order controller, the closed-loop system with that controller, clp, and the robust H performance of that system, clperf. Compute reduced-order controllers for orders ranging from 1 to 7.

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);
   clp = lft(P,Klow);
   [gamma,~] = dksynperf(clp);
   if gamma.UpperBound < 1.05*clperf
      break
   end
end 
order(Klow)
ans = 3

To validate the reduced-order controller, compare the robust H performance of the system using the simplified controller with that of the system using the full-order controller. The latter value is clperf, returned by dksyn when synthesizing the controller.

clplow = lft(P,Klow);
dksynperf(clplow)
ans = struct with fields:
           LowerBound: 0.7116
           UpperBound: 0.7131
    CriticalFrequency: 0.7408

clperf
clperf = 0.6816

The third-order controller achieves almost the same robust H performance as the 7th-order controller returned by dksyn.

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, dksynperf 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 an object you create with robOptions. 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, there exist some uncertain-element values of magnitude 1/LowerBound 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 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 peak gain 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 dksynperf 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 dksynperf. 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. dksynperf 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.

Compatibility Considerations

expand all

Not recommended starting in R2020a

Introduced in R2017a