TuningGoal.LQG class

Package: TuningGoal

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)).

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 = \lim_{T \to \infty} E (\frac{1}{T} \int_{0}^{T} z (t)' Q Z z (t) d t) .$

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

Construction

Req = TuningGoal.LQG(wname,zname,QW,QZ) creates an LQG requirement. 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

`wname`	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 `'w'` or `{'w','v'}`. The signals available to designate as noise inputs for the tuning goal are as follows. If you are using the tuning goal to tune a Simulink^® model of a control system, then `wname` can include: Any model input Any linearization input point in the model Any signal identified as a `Controls`, `Measurements`, `Switches`, or `IOs` signal in an `slTuner` interface associated with the Simulink model If you are using the tuning goal to tune a generalized state-space model (`genss`) of a control system using `systune`, then `wname` can include: Any input of the control system model Any channel of an `AnalysisPoint` block in the control system model For example, if you are tuning a control system model, `T`, then `wname` can be an input name contained in `T.InputName`. Also, if `T` contains an `AnalysisPoint` block with a location named `X`, then `wname` can include `X`. If you are using the tuning goal to tune a controller model, `C0` for a plant `G0`, using `looptune`, then `wname` can include: Any input of `C0` or `G0` Any channel of an `AnalysisPoint` block in `C0` or `G0` If `wname` is a channel of an `AnalysisPoint` block of a generalized model, the noise input for the tuning goal is the implied input associated with the switch:
`zname`	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 `'y'` or `{'y','u'}`. The signals available to designate as performance outputs for the tuning goal are as follows. If you are using the tuning goal to tune a Simulink model of a control system, then `zname` can include: Any model output Any linearization output point in the model Any signal identified as a `Controls`, `Measurements`, `Switches`, or `IOs` signal in an `slTuner` interface associated with the Simulink model If you are using the tuning goal to tune a generalized state-space model (`genss`) of a control system using `systune`, then `zname` can include: Any output of the control system model Any channel of an `AnalysisPoint` block in the control system model For example, if you are tuning a control system model, `T`, then `zname` can be an output name contained in `T.OutputName`. Also, if `T` contains an `AnalysisPoint` block with a channel named `X`, then `zname` can include `X`. If you are using the tuning goal to tune a controller model, `C0` for a plant `G0`, using `looptune`, then `zname` can include: Any input of `C0` or `G0` Any channel of an `AnalysisPoint` block in `C0` or `G0` If `zname` is a channel of an `AnalysisPoint` block of a generalized model, the performance output for the tuning goal is the implied output associated with the switch:
`QW`	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 continuous-time domain. In this assumption, w[k] is discrete-time 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_sQWd* for the `QW` value when creating the LQG goal. Default: I
`QZ`	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 `QZ` values to properly scale the cost function so that driving it below 1 or minimizing it yields the performance you require. Default: I

Properties

`NoiseCovariance`	Covariance matrix of the noise inputs w(t), specified as a matrix. The value of the `NoiseCovariance` property is set by the WZ input argument when you create the LQG tuning goal.
`PerformanceWeight`	Weights for the performance signals z(t), specified as a matrix. The value of the `PerformanceWeight` property is set by the QZ input argument when you create the LQG tuning goal.
`Input`	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 `Input` property is set by the `wname` input argument when you construct the tuning goal.
`Output`	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 `Output` property is set by the `zname` input argument when you construct the tuning goal.
`Models`	Models to which the tuning goal applies, specified as a vector of indices. Use the `Models` property when tuning an array of control system models with `systune`, to enforce a tuning goal for a subset of models in the array. For example, suppose you want to apply the tuning goal, `Req`, to the second, third, and fourth models in a model array passed to `systune`. To restrict enforcement of the tuning goal, use the following command: Req.Models = 2:4; When `Models = NaN`, the tuning goal applies to all models. Default: `NaN`
`Openings`	Feedback loops to open when evaluating the tuning goal, specified as a cell array of character vectors that identify loop-opening locations. The tuning goal is evaluated against the open-loop 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 `Openings` can include any linear analysis point marked in the model, or any linear analysis point in an `slTuner` (Simulink Control Design) interface associated with the Simulink model. Use `addPoint` (Simulink Control Design) to add analysis points and loop openings to the `slTuner` interface. Use `getPoints` (Simulink Control Design) to get the list of analysis points available in an `slTuner` interface to your model. If you are using the tuning goal to tune a generalized state-space (`genss`) model of a control system, then `Openings` can include any `AnalysisPoint` location in the control system model. Use `getPoints` to get the list of analysis points available in the `genss` model. For example, if `Openings = {'u1','u2'}`, then the tuning goal is evaluated with loops open at analysis points `u1` and `u2`. Default: `{}`
`Name`	Name of the tuning goal, specified as a character vector. For example, if `Req` is a tuning goal: Req.Name = 'LoopReq'; Default: `[]`

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₂ 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)).

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.