ml_ct_dss_hinfbt

H-infinity balanced truncation for descriptor systems.

Contents

Syntax

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

Description

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

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

Therefore, first an additive decomposition of the system is performed using the matrix disk function, such that

        [ Ei  0 ]       [ Ai  0 ]                        [ Ci ]
   E2 = [       ], A2 = [       ], B2 = [ Bi, Bp ], C2 = [    ],
        [ 0  Ep ]       [ 0  Ap ]                        [ Cp ]

with (Ei, Ai, Bi, Ci, D) belonging to the polynomial part and (Ep, Ap, Bp, Cp, 0) belonging to the strictly proper part. Now, the two generalized continuous-time Riccati equations

   Ap*Pp*Ep' + Ep*Pp*Ap' + Bp*Bp' - beta
       * (Ep*Pp*Cp' + B*M') * inv(Rb) * (Ep*Pp*Cp' + B*M')' = 0,
   Ap'*Qp*Ep + Ep'*Qp*Ap + Cp'*Cp - beta
       * (Bp'*Qp*Ep + M'*C)' * inv(Rc) * (Bp'*Qp*Ep + M'*C) = 0

are solved for the reduction of the strictly proper part, with beta = (1 - GAM^(-2)) and

   Rb = I + M*M',
   Rc = I + M'*M,

where M = D - Ci * inv(Ai) * Bi. Also, the two generalized discrete-time Lyapunov equations

   Ai*Pi*Ai' - Ei*Pi*Ei' - Bi*Bi' = 0,
   Ai'*Qi*Ai - Ei'*Qi*Ei - Ci'*Ci = 0

are solved for the reduction of the polynomial part. As result, a reduced-order system of the form

   Er*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 reduced-order transfer function Gr with an r-th order strictly proper part and the (right) coprime factorization sqrt(beta)*Gr = Nr*inv(Mr) it holds

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

with Hsvp 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

       [ s*E - A | B 0 B ]
       [ --------------- ]
       [       C | 0 0 0 ].
       [       0 | 0 0 I ]
       [       C | 0 I D ]
    Still, there is no known implementation of the Gamma-iteration
    for descriptor systems in MATLAB.
    In case of estimating/computing an optimal cost parameter GAM_OPT,
    the 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
E
matrix from (1) with dimensions n x n

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()
DecompEig
positive scalar, overestimation of the absolute value of the largest finite eigenvalue of s*E - A, if set, replaces the computation with DecompTol
default: []
DecompTol
nonnegative scalar, tolerance multiplied with the largest singular value of E to determine the smallest non-quasi-zero singular value of E
default: log(n)*eps
Gamma
positive scalar, used for the scaling of the Riccati equations, see GAM above
default: Inf
gdlyapdlopts
structure, containing the optional parameters for the computation of the generalized discrete-time Lyapunov equations, see ml_gdlyapdl_smith_fac
default: struct()
ImproperTrunc
{!}
nonnegative scalar, tolerance multiplied with the largest proper Hankel singular value of the system to truncate the improper part, if 0 no improper balanced truncation is performed
default: log(n)*eps
Index
nonnegative integer, index of the descriptor system used to set an upper bound on the size of the reduced improper part, Inf if unknown
default: Inf
infdecopts
structure, containing the optional parameters for the decomposition of the finite and infinite parts of the system using the disk function and subspace extraction method, see ml_disk and ml_getqz
default: struct()
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(Hsvp)) + Nu + Ni
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'
stabdecopts
structure, containing the optional parameters for the decomposition of the stable and unstable parts of the system using the sign function and subspace extraction method, , only used if RiccatiSolver = 'newton'see ml_signm and ml_getqz
default: struct()
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()
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

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
E
matrix from (3) with dimensions r x r

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
Hsvi
a vector, containing the computed Hankel singular values of the improper part of the system
Hsvp
a vector, containing the computed characteristic H-infinity singular values of the proper part of the system
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
infoADTF
structure, containing information about the additive decomposition of the system into its infinite, finite stable and finite anti-stable parts, see ml_ct_dss_adtf
infoGDLYAPDL
structure, containing information about the generalized discrete-time Lyapunov equation solver for the improper Gramians, see ml_gdlyapdl_smith_fac
infoPARTSTAB_C
structure, containing information about the partial stabilization used for the controllability Riccati equation, see ml_ct_dss_partstab
infoPARTSTAB_O
structure, containing information about the partial stabilization used for the observability Riccati equation, see ml_ct_dss_partstab
Nf
{!}
Dimension of the finite reduced part in the reduced-order model
Ni
{!}
Dimension of the improper part in 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

See Also

ml_ct_ss_hinfbt | ml_morlabopts