# Routine muub

Compute lower bounds on the (skewed) robust stability margin or upper bounds on the worst-case $\mathcal{H}_\infty$ norm.

### Description

Let us consider the following interconnections between a nominal LTI system $M(s)$ and a block-diagonal operator $\Delta(s)$.

If $M(s)$ has no exogenous input and output, a robust stability problem is considered: a (skew-)$\mu$ upper bound, i.e. a lower bound $k_{lb}$ on the robustness margin $k_{max}$, is computed (see problem 1 on the overview page of the toolbox for more details). The bound is guaranteed on a whole frequency interval, and the considered stability region can be bounded either by the imaginary axis or by a truncated sector.

If $M(s)$ has exogenous inputs $e$ and outputs $y$, a worst-case $\mathcal{H}_\infty$ performance problem is considered: an upper bound $\gamma_{ub}$ is computed on the highest $\mathcal{H}_\infty$ norm $\gamma_{max}$ of the transfer matrix between $e$ and $y$ when $\Delta(s)$ takes any admissible value (see problem 2 on the overview page of the toolbox for more details). The bound is guaranteed on a whole frequency interval, and the $\mathcal{H}_\infty$ norm can be computing either along the imaginary axis or along the boundary of a truncated sector.

Note: In both cases, the initial interconnection is normalized with convert_data before the problem is solved.

### Syntax

[ubnd,wc,iodesc]=muub(usys{,skew/perf,options}) [ubnd,wc,iodesc]=muub(gsys{,skew/perf,options}) [ubnd,wc,iodesc]=muub(lsys{,skew/perf,options}) [ubnd,wc,iodesc]=muub(sys,blk{,skew/perf,options})

### Input arguments

The interconnection between $M(s)$ and $\Delta(s)$ can be described by:

• a USS object usys,
• a GSS object gsys,
• a LFR object lsys,
• a LTI object sys describing the LTI system $M(s)$ and a $N\times 2$ matrix blk defining the structure of the block-diagonal operator $\Delta(s)=diag\left(\Delta_1(s),\dots,\Delta_N(s)\right)$:
• blk(i,:)=[-ni 0] $\Rightarrow$ $\Delta_i(s)=\delta_iI_{n_i}$ with $\delta_i$ real,
• blk(i,:)=[ni 0] $\Rightarrow$ $\Delta_i(s)=\delta_iI_{n_i}$ with $\delta_i$ complex,
• blk(i,:)=[ni mi] $\Rightarrow$ $\Delta_i(s)$ is a $n_i\times m_i$ LTI system.

For a robust stability problem, an additional input argument skew can be defined, indicating whether the maximum admissible $\mathcal{H}_\infty$ norm of each $\Delta_i(s)$ is bounded (skew(i)=0) or not (skew(i)=1). If skew is undefined, skew(i) is set to 1 for all $i=1,\dots,N$, which means that a classical $\mu$ problem is considered.

For a worst-case $\mathcal{H}_\infty$ performance problem, an additional input argument perf can be defined to specify how the transfer between $e$ and $y$ is structured. Each line of perf corresponds to a performance channel. For example, if perf=[2 1;1 3], the transfer between inputs 1-2 and output 1 is considered independently of the one between input 3 and outputs 2-3-4. If perf is undefined, it is set to [ne ny], where ne and ny denote the size of the signals $e$ and $y$.

The last input argument options is an optional structured variable with fields:

 freq Frequency interval $\Omega$ in rad/s on which the bound is to be computed. The default value is options.freq=[0 10*max(abs(eig(sys)))]. sector Vector $[\alpha\ \xi]$ or $[\alpha\ \xi\ \omega_c]$ characterizing the considered truncated sector (see display_sector for a complete description). The default value is options.sector=[0 0], which means that the left half plane is considered. lmi If options.lmi=1, the LMI-based characterization of a (skew-)$\mu$ upper bound is used instead of the $\overline{\sigma}$-based one for better accuracy. The default value is options.lmi=0. Note that setting options.lmi=1 in the presence of highly repeated parametric uncertainties (i.e. blocks $\Delta_i(s)=\delta_iI_{n_i}$ with $n_i\ge 10$), may lead to high computational costs. target The algorithm is interrupted if the (skew-)$\mu$ upper bound or the upper bound on the worst-case $\mathcal{H}_\infty$ norm exceeds options.target. The default value is options.target=Inf. trace Trace of execution. The default value is options.trace=1. warn Warnings display. The default value is options.warn=1.

Additional fields can be defined (see muub_mixed), but the ones listed above are usually sufficient for non-expert users.

### Output arguments

 ubnd Lower bound $k_{lb}$ on the robustness margin for the normalized interconnection, or upper bound $\gamma_{ub}$ on the worst-case $\mathcal{H}_\infty$ norm for each performance channel, on the considered frequency interval $\Omega$. wc Frequency $\omega_c$ in rad/s for which $k_{lb}$ or $\gamma_{ub}$ has been computed. iodesc Cell array of structured variables: The name of the ith uncertainty $\Delta_i(s)$ is given by iodesc{i}.name. Its type is given by iodesc{i}.type: 'real scalar' $\Rightarrow$ $\Delta_i(s)=\delta_iI_{n_i}$ with $\delta_i$ real, 'complex scalar' $\Rightarrow$ $\Delta_i(s)=\delta_iI_{n_i}$ with $\delta_i$ complex, 'dynamical system' $\Rightarrow$ $\Delta_i(s)$ is a $n_i\times m_i$ LTI system. A third field gives the values of $\Delta_i(s)$ for which the stability of the initial interconnection is guaranteed (robust stability problem) or the $\mathcal{H}_\infty$ norm of the transfer between $e$ and $y$ is guaranteed to be less than $\gamma_{ub}$ (worst-case $\mathcal{H}_\infty$ performance problem): if iodesc{i}.type='real scalar', $\delta_i$ belongs to the real interval iodesc{i}.range, if iodesc{i}.type='complex scalar', $\delta_i$ belongs to the disc of center iodesc{i}.disc(1) and radius iodesc{i}.disc(2), if iodesc{i}.type='dynamical system', $\overline{\sigma}(\Delta_i(p(\omega)))<|W(p(\omega))|$ for all $\omega\in\Omega$, where $p(\omega)$ denotes the point $j\omega$ on the imaginary axis or the corresponding point on the boundary of the truncated sector defined by options.sector, and where a representation of $W(s)$ is given by iodesc{i}.bound. In case a worst-case $\mathcal{H}_\infty$ performance problem is considered, the last cell of iodesc is associated to the performance channels. In this case, iodesc{end}.name='', iodesc{end}.type='performance channel' and iodesc{end}.maxnorm contains the upper bound $\gamma_{ub}$ on the worst-case $\mathcal{H}_\infty$ norm for each performance channel.

### Examples

1. Robust stability problem

Description of the uncertain system by a USS object:
a1=ureal('a',5,'Percentage',20); b1=ucomplex('b',4+3*sqrt(-1),'Percentage',40); c1=ultidyn('c',[2 1],'Bound',2,'Type','GainBounded'); A1=[-3*a1*b1-2 1;a1 -b1^2-1]+c1*[a1 -b1]; usys=lft(tf({1 0;0 1},[1 0]),A1); usys=simplify(usys,'full');
Computation of a lower bound $k_{lb}$ on the robustness margin $k_{max}$ for the normalized interconnection:
options.lmi=1; [ubnd1,wc1,iodesc1]=muub(usys,options); k_lb=1/ubnd1
Values of $\Delta(s)$ for which the stability of the initial interconnection is guaranteed:
iodesc1{:}

Description of the uncertain system by a GSS object:
a3=gss('a',5,[4 6]); b3=gss('b',4+3i,[4 3 2]); c3=gss('c','LTI',[2 1],0,2); A3=[-3*a3*b3-2 1;a3 -b3^2-1]+c3*[a3 -b3]; gsys=abcd2gss(A3,2);
Computation of a lower bound $k_{lb}$ on the robustness margin $k_{max}$ for the normalized interconnection:
options.lmi=1; [ubnd3,wc3,iodesc3]=muub(gsys,options); k_lb=1/ubnd3
Values of $\Delta(s)$ for which the stability of the initial interconnection is guaranteed:
iodesc3{:}

2. Worst-case $\mathcal{H}_\infty$ performance problem

Description of the uncertain system by a LFR object:
a2=lfr('a','ltisr',1,[4 6],'minmax'); b2=lfr('b','ltisc',1,[4+3*sqrt(-1) 2],'disc'); c2=lfr('c','ltifc',[2 1],ltisys([],[],[],2),'freq'); d2=lfr('d','ltifc',[2 2],ltisys(-1,1,3,2),'freq'); A2=[-3*a2*b2-2 1;a2 -b2^2-1]+c2*[a2 -b2]; B2=[1 3;2 a2]; C2=d2*[b2 1;2 -3]; D2=[0 2;0 1]; lsys=abcd2lfr([A2 B2;C2 D2],2); lsys=minlfr(lsys); size(lsys)
Computation of an upper bound $\gamma_{ub}$ on the worst-case $\mathcal{H}_\infty$ norm $\gamma_{max}$:
options.lmi=1; [ubnd2,wc2,iodesc2]=muub(lsys,options); gamma_ub=ubnd2
Values of $\Delta(s)$ for which the worst-case $\mathcal{H}_\infty$ norm is guaranteed to be less than $\gamma_{ub}$ for the initial interconnection:
iodesc2{:}

muub_mixed
convert_data
make_square