hinffc

Full-control H-infinity synthesis

Syntax

``[K,CL,gamma] = hinffc(P,nmeas)``
``[K,CL,gamma] = hinffc(P,nmeas,gamTry)``
``[K,CL,gamma] = hinffc(P,nmeas,gamRange)``
``[K,CL,gamma] = hinffc(___,opts)``
``[K,CL,gamma,info] = hinffc(___)``

Description

Full-control synthesis assumes the controller can directly affect both the state vector x and the error signal z. Synthesis with `hinffc` is the dual of the full-information problem covered by `hinffi`. For general H synthesis, use `hinfsyn`.

````[K,CL,gamma] = hinffc(P,nmeas)` computes the H∞-optimal control law$u=\left[\begin{array}{c}{u}_{1}\\ {u}_{2}\end{array}\right]=Ky$for the plant `P`. The plant is described by the state-space equations:$\begin{array}{c}dx=Ax+{B}_{1}w+{u}_{1}\\ z={C}_{1}x+{D}_{11}w+{u}_{2}\\ y={C}_{2}x+{D}_{21}w.\end{array}$Here, w represents the disturbance inputsu1 represents the inputs that affect the state vectoru2 represents the inputs that affect the errorz represents the error outputs to be kept smally represents the measurement outputs`nmeas` is the number of measurements y, which must be the last outputs of `P`. The gain matrix `K` minimizes the H∞ norm of the closed-loop transfer function `CL` from the disturbance signals w to the error signals z. ```
````[K,CL,gamma] = hinffc(P,nmeas,gamTry)` calculates a gain matrix for the target performance level `gamTry`. Specifying `gamTry` can be useful when the optimal achievable performance is better than you need for your application. In that case, a less-than-optimal solution can have smaller gains and be more numerically well-conditioned. If `gamTry` is not achievable, `hinffc` returns `[]` for `K` and `CL`, and `Inf` for `gamma`. ```
````[K,CL,gamma] = hinffc(P,nmeas,gamRange)` searches the range `gamRange` for the best achievable performance. Specify the range with a vector of the form `[gmin,gmax]`. Limiting the search range can speed up computation by reducing the number of iterations performed to test different performance levels. ```
````[K,CL,gamma] = hinffc(___,opts)` specifies additional computation options. To create `opts`, use `hinfsynOptions`. Specify `opts` after all other input arguments.```
````[K,CL,gamma,info] = hinffc(___)` returns a structure containing additional information about the H∞ synthesis computation. You can use this argument with any of the previous syntaxes.```

Input Arguments

collapse all

Plant, specified as an LTI model such as a state-space (`ss`) model. If `P` is a generalized state-space model with uncertain or tunable control design blocks, then `hinffc` uses the nominal or current value of those elements.

Construct `P` so that it has the partitioned form

`$\begin{array}{c}dx=Ax+{B}_{1}w+{u}_{1}\\ z={C}_{1}x+{D}_{11}w+{u}_{2}\\ y={C}_{2}x+{D}_{21}w.\end{array}$`

Here,

• w represents the disturbance inputs

• u1 represents the inputs that affect the state vector

• u2 represents the inputs that affect the error

• z represents the error outputs to be kept small

• y represents the measurement outputs

Construct `P` such that the `nmeas` measurement outputs are the last outputs.

For information about conditions imposed on the plant matrices and how the software addresses them, see `hinfsyn`.

Number of measurement output signals in the plant, specified as a nonnegative integer. `hinffc` takes the last `nmeas` plant outputs as the measurements y. The returned gain matrix `K` has `nmeas` inputs.

Target performance level, specified as a positive scalar. `hinffc` attempts to compute a gain matrix such that the H of the closed-loop system does not exceed `gamTry`. If this performance level is achievable, then the returned gain matrix has `gamma``gamTry`. If `gamTry` is not achievable, `hinffc` returns an empty matrix.

Performance range for search, specified as a vector of the form `[gmin,gmax]`. The `hinffc` command tests only performance levels within that range. It returns a gain matrix with performance:

• `gamma``gmin`, when `gmin` is achievable.

• `gmin` < `gamma` < `gmax`, when `gmax` is achievable and but `gmin` is not.

• `gamma` = `Inf` when `gmax` is not achievable. In this case, `hinffc` returns `[]` for `K` and `CL`.

If you know a range of feasible performance levels, specifying this range can speed up computation by reducing the number of iterations performed by `hinffc` to test different performance levels.

Additional options for the computation, specified as an options object you create using `hinfsynOptions`. Available options include displaying algorithm progress at the command line, turning off automatic scaling and regularization, and specifying an optimization method. For more information, see `hinfsynOptions`.

Output Arguments

collapse all

Gain matrix, returned as a matrix or `[]`. The gain-matrix dimensions are nu-by-`nmeas`, where nu is the number of states plus the number of error outputs of `P` (outputs not included in `nmeas`).

If you supply `gamTry` or `gamRange` and the specified performance values are not achievable, then `K` = `[]`.

Closed-loop transfer function, returned as a state-space (`ss`) model object or `[]`. The returned performance level `gamma` is the H norm of `CL`.

If you supply `gamTry` or `gamRange` and the specified performance levels are not achievable, then `CL` = `[]`.

Closed-loop performance, returned as a nonnegative scalar value or `Inf`. This value is the H norm of `CL`. If you do not provide performance levels to test using `gamTry` or `gamRange`, then `gamma` is the best achievable performance level.

If you provide `gamTry` or `gamRange`, then `gamma` is the actual performance level achieved by the gain matrix computed for the best passing performance level that the function tries. If the specified performance levels are not achievable, then `gamma` = `Inf`.

Additional synthesis data, returned as a structure or `[]` (if the specified performance level is not achievable). `info` has the following fields.

FieldDescription
`gamma`

Performance level used to compute the gain matrix `K`, returned as a nonnegative scalar. Typically, `hinffc` tests multiple target performance levels and returns a gain matrix corresponding to the best passing performance level (see the Algorithms section of `hinfsyn` for details). The value `info.gamma` is an upper limit on the actual achieved performance returned as the output argument `gamma`.

`Y`

Riccati solution Y for the performance level `info.gamma`, returned as matrix. For more information, see the Algorithms section of `hinfsyn`.

`Preg`

Regularized plant used for `hinffc` computation, returned as a state-space (`ss`) model object. By default, `hinffc` automatically adds extra disturbances and errors to the plant to ensure that it meets certain conditions (see the Algorithms section of `hinfsyn`). The field `info.Preg` contains the resulting plant model.

Algorithms

For information about the algorithms used for H synthesis, see `hinfsyn`.

References

[1] Doyle, J.C., K. Glover, P. Khargonekar, and B. Francis. "State-space solutions to standard H2 and H control problems." IEEE Transactions on Automatic Control, Vol 34, Number 8, August 1989, pp. 831–847.