Package: TuningGoal
LinearQuadraticGaussian (LQG) goal for control system tuning
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)).
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.
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.
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.

Noise inputs, w(t), specified as
a character vector or a cell array of character vectors, that designate
the signals making up w(t) by
name, such as
If 

Performance outputs, z(t),
specified as a character vector or a cell array of character vectors,
that designate the signals making up
z(t) by name, such as
If 

Covariance of the white noise input vector w(t), specified as a scalar or a matrix. Use a scalar value to specify a multiple of the identity matrix. Otherwise specify a symmetric nonnegative definite matrix with as many rows as there are entries in the vector w(t). A diagonal matrix means the entries of w(t) are uncorrelated. The covariance of w(t is given by: E(w(t)w(t)′) = QW. When you are tuning a control system in discrete time, the LQG tuning goal assumes: E(w[k]w[k]′) = QW/T_{s}. T_{s} is the model sample time.
This assumption ensures consistent results with tuning in the
continuoustime domain. In this assumption,
w[k] is discretetime noise
obtained by sampling continuous white noise
w(t) with covariance
QW. If in your system
w[k] is a truly discrete
process with known covariance QWd, use the value
T_{s}*QWd for the
Default: I 

Performance weights, specified as a scalar or a matrix. Use a scalar value to specify a multiple of the identity matrix. Otherwise specify a symmetric nonnegative definite matrix. Use a diagonal matrix to independently scale or penalize the contribution of each variable in z. The performance weights contribute to the cost function according to: J = E(z(t)′ QZ z(t)). When you use the LQG tuning goal 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 Default: I 

Covariance matrix of the noise inputs
w(t), specified as a matrix. The
value of the 

Weights for the performance signals
z(t), specified as a matrix. The
value of the 

Noise input signal names, specified as a cell array of character vectors.
The input signal names specify the inputs of the transfer function that the
tuning goal constrains. The initial value of the 

Performance output signal names, specified as a cell array of character
vectors. The output signal names specify the outputs of the transfer
function that the tuning goal constrains. The initial value of the


Models to which the tuning goal applies, specified as a vector of indices. Use the Req.Models = 2:4; When Default: 

Feedback loops to open when evaluating the tuning goal, specified as a cell array of character vectors that identify loopopening locations. The tuning goal is evaluated against the openloop configuration created by opening feedback loops at the locations you identify. If you are using the tuning goal to tune a Simulink model
of a control system, then If you are using the tuning goal to tune a generalized statespace
( For example, if Default: 

Name of the tuning goal, specified as a character vector. For example, if Req.Name = 'LoopReq'; Default: 
When you use this tuning goal to tune a continuoustime 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 continuoustime 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 statespace 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 closedloop
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.
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)).
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.
TuningGoal.Variance
 TuningGoal.WeightedVariance
 evalGoal
 slTuner
 systune
 systune (for slTuner)
 viewGoal