SB10QD - SLICOT Library Routine Documentation

## SB10QD

### State feedback and output injection matrices for an H-infinity (sub)optimal state controller (continuous-time)

[Specification] [Arguments] [Method] [References] [Comments] [Example]

Purpose

      To compute the state feedback and the output injection
      matrices for an H-infinity (sub)optimal n-state controller,
      using Glover's and Doyle's 1988 formulas, for the system

                    | A  | B1  B2  |   | A | B |
                P = |----|---------| = |---|---|
                    | C1 | D11 D12 |   | C | D |
                    | C2 | D21 D22 |

      and for a given value of gamma, where B2 has as column size the
      number of control inputs (NCON) and C2 has as row size the number
      of measurements (NMEAS) being provided to the controller.

      It is assumed that

      (A1) (A,B2) is stabilizable and (C2,A) is detectable,

      (A2) D12 is full column rank with D12 = | 0 | and D21 is
                                              | I |
           full row rank with D21 = | 0 I | as obtained by the
           subroutine SB10PD,

      (A3) | A-j*omega*I  B2  | has full column rank for all omega,
           |    C1        D12 |

      (A4) | A-j*omega*I  B1  |  has full row rank for all omega.
           |    C2        D21 |

Specification

          SUBROUTINE SB10QD( N, M, NP, NCON, NMEAS, GAMMA, A, LDA, B, LDB,
         $                   C, LDC, D, LDD, F, LDF, H, LDH, X, LDX, Y, LDY,
         $                   XYCOND, IWORK, DWORK, LDWORK, BWORK, INFO )
    C     .. Scalar Arguments ..
          INTEGER            INFO, LDA, LDB, LDC, LDD, LDF, LDH, LDWORK,
         $                   LDX, LDY, M, N, NCON, NMEAS, NP
          DOUBLE PRECISION   GAMMA
    C     .. Array Arguments ..
          INTEGER            IWORK( * )
          DOUBLE PRECISION   A( LDA, * ), B( LDB, * ), C( LDC, * ),
         $                   D( LDD, * ), DWORK( * ),  F( LDF, * ),
         $                   H( LDH, * ), X( LDX, * ), XYCOND( 2 ),
         $                   Y( LDY, * )
          LOGICAL            BWORK( * )

Arguments

Input/Output Parameters

      N       (input) INTEGER
              The order of the system.  N >= 0.

      M       (input) INTEGER
              The column size of the matrix B.  M >= 0.

      NP      (input) INTEGER
              The row size of the matrix C.  NP >= 0.

      NCON    (input) INTEGER
              The number of control inputs (M2).  M >= NCON >= 0,
              NP-NMEAS >= NCON.

      NMEAS   (input) INTEGER
              The number of measurements (NP2).  NP >= NMEAS >= 0,
              M-NCON >= NMEAS.

      GAMMA   (input) DOUBLE PRECISION
              The value of gamma. It is assumed that gamma is
              sufficiently large so that the controller is admissible.
              GAMMA >= 0.

      A       (input) DOUBLE PRECISION array, dimension (LDA,N)
              The leading N-by-N part of this array must contain the
              system state matrix A.

      LDA     INTEGER
              The leading dimension of the array A.  LDA >= max(1,N).

      B       (input) DOUBLE PRECISION array, dimension (LDB,M)
              The leading N-by-M part of this array must contain the
              system input matrix B.

      LDB     INTEGER
              The leading dimension of the array B.  LDB >= max(1,N).

      C       (input) DOUBLE PRECISION array, dimension (LDC,N)
              The leading NP-by-N part of this array must contain the
              system output matrix C.

      LDC     INTEGER
              The leading dimension of the array C.  LDC >= max(1,NP).

      D       (input) DOUBLE PRECISION array, dimension (LDD,M)
              The leading NP-by-M part of this array must contain the
              system input/output matrix D.

      LDD     INTEGER
              The leading dimension of the array D.  LDD >= max(1,NP).

      F       (output) DOUBLE PRECISION array, dimension (LDF,N)
              The leading M-by-N part of this array contains the state
              feedback matrix F.

      LDF     INTEGER
              The leading dimension of the array F.  LDF >= max(1,M).

      H       (output) DOUBLE PRECISION array, dimension (LDH,NP)
              The leading N-by-NP part of this array contains the output
              injection matrix H.

      LDH     INTEGER
              The leading dimension of the array H.  LDH >= max(1,N).

      X       (output) DOUBLE PRECISION array, dimension (LDX,N)
              The leading N-by-N part of this array contains the matrix
              X, solution of the X-Riccati equation.

      LDX     INTEGER
              The leading dimension of the array X.  LDX >= max(1,N).

      Y       (output) DOUBLE PRECISION array, dimension (LDY,N)
              The leading N-by-N part of this array contains the matrix
              Y, solution of the Y-Riccati equation.

      LDY     INTEGER
              The leading dimension of the array Y.  LDY >= max(1,N).

      XYCOND  (output) DOUBLE PRECISION array, dimension (2)
              XYCOND(1) contains an estimate of the reciprocal condition
                        number of the X-Riccati equation;
              XYCOND(2) contains an estimate of the reciprocal condition
                        number of the Y-Riccati equation.

Workspace

      IWORK   INTEGER array, dimension
              (max(2*max(N,M-NCON,NP-NMEAS),N*N))

      DWORK   DOUBLE PRECISION array, dimension (LDWORK)
              On exit, if INFO = 0, DWORK(1) contains the optimal
              LDWORK.

      LDWORK  INTEGER
              The dimension of the array DWORK.
              LDWORK >= max(1,M*M + max(2*M1,3*N*N +
                                        max(N*M,10*N*N+12*N+5)),
                            NP*NP + max(2*NP1,3*N*N +
                                        max(N*NP,10*N*N+12*N+5))),
              where M1 = M - M2 and NP1 = NP - NP2.
              For good performance, LDWORK must generally be larger.
              Denoting Q = MAX(M1,M2,NP1,NP2), an upper bound is
              max(1,4*Q*Q+max(2*Q,3*N*N + max(2*N*Q,10*N*N+12*N+5))).

      BWORK   LOGICAL array, dimension (2*N)

Error Indicator

      INFO    INTEGER
              = 0:  successful exit;
              < 0:  if INFO = -i, the i-th argument had an illegal
                    value;
              = 1:  if the controller is not admissible (too small value
                    of gamma);
              = 2:  if the X-Riccati equation was not solved
                    successfully (the controller is not admissible or
                    there are numerical difficulties);
              = 3:  if the Y-Riccati equation was not solved
                    successfully (the controller is not admissible or
                    there are numerical difficulties).

Method

      The routine implements the Glover's and Doyle's formulas [1],[2]
      modified as described in [3]. The X- and Y-Riccati equations
      are solved with condition and accuracy estimates [4].

References

      [1] Glover, K. and Doyle, J.C.
          State-space formulae for all stabilizing controllers that
          satisfy an Hinf norm bound and relations to risk sensitivity.
          Systems and Control Letters, vol. 11, pp. 167-172, 1988.

      [2] Balas, G.J., Doyle, J.C., Glover, K., Packard, A., and
          Smith, R.
          mu-Analysis and Synthesis Toolbox.
          The MathWorks Inc., Natick, Mass., 1995.

      [3] Petkov, P.Hr., Gu, D.W., and Konstantinov, M.M.
          Fortran 77 routines for Hinf and H2 design of continuous-time
          linear control systems.
          Rep. 98-14, Department of Engineering, Leicester University,
          Leicester, U.K., 1998.

      [4] Petkov, P.Hr., Konstantinov, M.M., and Mehrmann, V.
          DGRSVX and DMSRIC: Fortan 77 subroutines for solving
          continuous-time matrix algebraic Riccati equations with
          condition and accuracy estimates.
          Preprint SFB393/98-16, Fak. f. Mathematik, Tech. Univ.
          Chemnitz, May 1998.

Numerical Aspects

      The precision of the solution of the matrix Riccati equations
      can be controlled by the values of the condition numbers
      XYCOND(1) and XYCOND(2) of these equations.

Further Comments

      The Riccati equations are solved by the Schur approach
      implementing condition and accuracy estimates.

Example

Program Text

      None

Program Data

      None

Program Results

      None

Return to Supporting Routines index