ml_ct_ss_hinfbt

H-infinity balanced truncation for standard systems.

Contents

Syntax

[Ar, Br, Cr, Dr, info] = ml_ct_ss_hinfbt(A, B, C, D)
[Ar, Br, Cr, Dr, info] = ml_ct_ss_hinfbt(A, B, C, D, opts)
[rom, info] = ml_ct_ss_hinfbt(sys)
[rom, info] = ml_ct_ss_hinfbt(sys, opts)

Description

This function computes the H-infinity balanced truncation for a standard system of the form

   x'(t) = A*x(t) + B*u(t),                                        (1)
    y(t) = C*x(t) + D*u(t).                                        (2)

Therefor, the two algebraic Riccati equations

   A*P  + P*A' + B*B'
       - beta * (P*C' + B*D') * inv(Rb) * (P*C' + B*D')' = 0,
   A'*Q + Q*A  + C'*C
       - beta * (B'*Q + D'*C)' * inv(Rc) * (B'*Q + D'*C) = 0,

are solved for the Gramians P and Q, with beta = (1 - GAM^(-2)) and

   Rb = I + D*D',
   Rc = I + D'*D.

As result, a reduced-order system of the form

   x'(t) = Ar*x(t) + Br*u(t),                                      (3)
    y(t) = Cr*x(t) + Dr*u(t)                                       (4)

is computed, such that for the original transfer function G with the (right) coprime factorization sqrt(beta)*G = N*inv(M) and the r-th order transfer function Gr with the (right) coprime factorization sqrt(beta)*Gr = Nr*inv(Mr) it holds

   1/sqrt(beta) * ||[N; M] - [Nr; Mr]||_{\infty} <=
       2 * (Hsv(r+1) / sqrt(1 + (beta*Hsv(r+1))^2) + ...
       + Hsv(n)/sqrt(1 + (beta*Hsv(n))^2)),

with Hsv, a vector containing the characteristic H-infinity singular values of the system.

Note: 1) The parameter GAM refers to the optimal cost gamma computed during the H-infinity controller construction of the LQG normalized system with feed-through term

       [ A | B 0 B ]
       [ --------- ]
       [ C | 0 0 0 ],
       [ 0 | 0 0 I ]
       [ C | 0 I D ]
    which can be constructed by
       sys_normal = ss(A, ...
                       [B, zeros(n,p), B], ...
                       [C; zeros(m,n); C], ...
                       [zeros(p,m), zeros(p,p), zeros(p,m);
                        zeros(m,m), zeros(m,p), eye(m,m);
                        zeros(p,m), eye(p,p), D]).
    Then an optimal parameter GAM_OPT can be computed by
       [K, CL, GAM_OPT, INFO] = hinfsyn(sys_normal, p, m).
    In this case, the parameter GAM > GAM_OPT can be chosen
    arbitrarily.
    By default, the maximum of 1 and the given GAM is disturbed by
    0.01% before used for computations.
 2) In the case of GAM == Inf, the H-infinity balanced truncation is
    identical to the LQG balanced truncation.

Input

Entry
Meaning
A
matrix from (1) with dimensions n x n
B
matrix from (1) with dimensions n x m
C
matrix from (2) with dimensions p x n
D
matrix from (2) with dimensions p x m

Parameter
Meaning
Beta
nonnegative scalar, used as shift of the in Bass' algorithm for better conditioning if StabMethod == 'lyap' is chosen only used if RiccatiSolver = 'newton'
default: 0.1
caredlopts
structure, containing the optional parameters for the Riccati equation sign function solver, only used if RiccatiSolver = 'sign', see ml_caredl_sgn_fac
default: struct()
careopts
structure, containing the optional parameters for the computation of the continuous-time algebraic Riccati equations, only used if RiccatiSolver = 'newton', see ml_care_nwt_fac
default: struct()
Gamma
positive scalar, used for the scaling of the Riccati equations, see GAM above
default: Inf
Method
{!}
character array, determining algorithm for the computation of the reduced-order model
  • 'sr' - square-root method
  • 'bfsr' - balancing-free square-root method
default: 'sr'
Order
{!}
positive integer, order of the resulting reduced-order model chosen by the user if 'order' is set for OrderComputation
default: min(10,length(Hsv)) + Nu
OrderComputation
{!}
character array, determining the method for the computation of the size of the reduced-order model
  • 'order' - take explicit order
  • 'tolerance' - using absolute error bound
default: 'tolerance'
RiccatiSolver
character array, determining the solver for the dual Riccati equations
  • 'newton' - Newton iteration
  • 'sign' - dual sign function method
default: 'sign'
StabMethod
character array, determining the method of stabilization of the system, only used if RiccatiSolver = 'newton'
  • 'cabe' - partial stabilization with the algebraic Bernoulli equation
  • 'lyap' - partial stabilization with Bass' algorithm
default: 'cabe'
stabmethodopts
structure, containing the optional parameters for the sign function based Lyapunov or Bernoulli equation solver used for the stabilization, only used if RiccatiSolver = 'newton', see ml_cabe_sgn or ml_lyap_sgn
default: struct()
stabsignmopts
structure, containing the optional parameters for the matrix sign function used for the decomposition into stable and anti-stable system parts, only used if RiccatiSolver = 'newton', see ml_signm
default: struct()
StoreProjection
{0, 1}, used to disable/enable storing of the computed projection matrices W and T
default: 0
Tolerance
{!}
nonnegative scalar, tolerance used for the computation of the size of the reduced-order model by an absolute error bound if 'tolerance' is set for OrderComputation
default: 1.0e-02
UnstabDim
integer, dimension of the deflating anti-stable subspace in the control and filter Riccati equations, only used if RiccatiSolver = 'newton', negative if unknown
default: -1

Note: Parameters marked with {!} may also be a cell array containing multiple arguments. In this case an cell array of the same size is returned with one entry computed for each input argument and the marked fields of the info struct are cells as well. When multiple arguments are given as cells, they are expected to have the same length.

Output

Entry
Meaning
A
matrix from (3) with dimensions r x r
B
matrix from (3) with dimensions r x m
C
matrix from (4) with dimensions p x r
D
matrix from (4) with dimensions p x m

Entry
Meaning
AbsErrBound
{!}
computed error bound for the absolute error of the (right) coprime factorization in H-infinity norm
Gamma
positive scalar, the disturbed scaling parameter of the computations
Hsv
a vector, containing the computed characteristic H-infinity singular values
infoCARE_C
structure, containing information about the Newton solver for the regulator Riccati equation, see ml_care_nwt_fac
infoCARE_O
structure, containing information about the Newton solver for the filter Riccati equation, see ml_care_nwt_fac
infoCAREDL
structure, containing information about the sign function solver for the dual Riccati equations, see ml_caredl_sgn_fac
infoPARTSTAB_C
structure, containing information about the partial stabilization used for the controllability Riccati equation, see ml_ct_ss_partstab
infoPARTSTAB_O
structure, containing information about the partial stabilization used for the observability Riccati equation, see ml_ct_ss_partstab
N
{!}
Dimension of the reduced-order model
T
{!}
projection matrix used as right state-space transformation to obtain the resulting block system, if opts.StoreProjection == 1
W
{!}
projection matrix used as left state-space transformation to obtain the resulting block system, if opts.StoreProjection == 1

Reference

D. Mustafa, K. Glover, Controller reduction by Hinf-balanced truncation, IEEE Trans. Autom. Control 36 (6) (1991) 668--682. https://doi.org/10.1109/9.86941

See Also

ml_ct_dss_hinfbt | ml_morlabopts