# TuningGoal.LQG

Linear-Quadratic-Gaussian (LQG) goal for control system tuning

## Description

Use `TuningGoal.LQG`

to specify a tuning goal
that quantifies control performance as an LQG cost. It is applicable to any control
structure, not just the classical observer structure of optimal LQG control. You can use
this tuning goal for control system tuning with tuning commands, such as
`systune`

or `looptune`

.

The LQG cost is given by:

J =
E(z(t)′
QZ
z(t)). | (1) |

*z*(*t*) is the system response to a white noise
input vector *w*(*t*). The covariance of
*w*(*t*) is given by:

E(w(t)w(t)′)
= QW. | (2) |

The vector *w*(*t*) typically consists of external
inputs to the system such as noise, disturbances, or command. The vector
*z*(*t*) includes all the system variables that
characterize performance, such as control signals, system states, and outputs.
*E*(*x*) denotes the expected value of the
stochastic variable *x*.

The cost function *J* can also be written as an average over
time:

$$J=\underset{T\to \infty}{\mathrm{lim}}E\left(\frac{1}{T}{\displaystyle {\int}_{0}^{T}z\left(t\right)}\text{'}\text{\hspace{0.17em}}QZ\text{\hspace{0.17em}}z\left(t\right)dt\right).$$

After you create a tuning goal, you can further configure it by setting Properties of the object.

## Creation

### Description

creates an LQG requirement. `Req`

=
TuningGoal.LQG(`wname`

,`zname`

,`QW`

,`QZ`

)`wname`

and
`zname`

specify the signals making up
*w*(*t*) and
*z*(*t*). The matrices
`QW`

and `QZ`

specify the noise
covariance and performance weight. These matrices must be symmetric
nonnegative definite. Use scalar values for `QW`

and
`QZ`

to specify multiples of the identity
matrix.

### Input Arguments

## Properties

## Tips

When you use this tuning goal to tune a continuous-time control system,

`systune`

attempts to enforce zero feedthrough (*D*= 0) on the transfer that the tuning goal constrains. Zero feedthrough is imposed because the*H*_{2}norm, and therefore the value of the tuning goal, is infinite for continuous-time systems with nonzero feedthrough.`systune`

enforces zero feedthrough by fixing to zero all tunable parameters that contribute to the feedthrough term.`systune`

returns an error when fixing these tunable parameters is insufficient to enforce zero feedthrough. In such cases, you must modify the tuning goal or the control structure, or manually fix some tunable parameters of your system to values that eliminate the feedthrough term.When the constrained transfer function has several tunable blocks in series, the software’s approach of zeroing all parameters that contribute to the overall feedthrough might be conservative. In that case, it is sufficient to zero the feedthrough term of one of the blocks. If you want to control which block has feedthrough fixed to zero, you can manually fix the feedthrough of the tuned block of your choice.

To fix parameters of tunable blocks to specified values, use the

`Value`

and`Free`

properties of the block parametrization. For example, consider a tuned state-space block:`C = tunableSS('C',1,2,3);`

To enforce zero feedthrough on this block, set its

*D*matrix value to zero, and fix the parameter.C.D.Value = 0; C.D.Free = false;

For more information on fixing parameter values, see the Control Design Block reference pages, such as

`tunableSS`

.This tuning goal imposes an implicit stability constraint on the closed-loop transfer function from

`wname`

to`zname`

, evaluated with loops opened at the points identified in`Openings`

. The dynamics affected by this implicit constraint are the*stabilized dynamics*for this tuning goal. The`MinDecay`

and`MaxRadius`

options of`systuneOptions`

control the bounds on these implicitly constrained dynamics. If the optimization fails to meet the default bounds, or if the default bounds conflict with other requirements, use`systuneOptions`

to change these defaults.

## Algorithms

When you tune a control system using a `TuningGoal`

, the software
converts the tuning goal into a normalized scalar value
*f*(*x*). *x* is the vector of
free (tunable) parameters in the control system. The software then adjusts the parameter
values to minimize *f*(*x*), or to drive
*f*(*x*) below 1 if the tuning goal is a hard
constraint.

For `TuningGoal.LQG`

, *f*(*x*) is
given by the cost function *J*:

J =
E(z(t)′
QZ
z(t)). | (6) |

When you use the LQG requirement as a hard goal, the software tries to drive the cost
function *J* < 1. When you use it as a soft goal, the cost function
*J* is minimized subject to any hard goals and its value is
contributed to the overall objective function. Therefore, select `QZ`

values to properly scale the cost function so that driving it below 1 or minimizing it
yields the performance you require.

## Version History

**Introduced in R2016a**

## See Also

`systune`

| `slTuner`

(Simulink Control Design) | `systune (for slTuner)`

(Simulink Control Design) | `viewGoal`

| `evalGoal`

| `TuningGoal.WeightedVariance`

| `TuningGoal.Variance`