# TuningGoal.Tracking

Tracking requirement for control system tuning

## Description

Use `TuningGoal.Tracking`

to specify a
frequency-domain tracking requirement between specified inputs and outputs. This tuning goal
specifies the maximum relative error (gain from reference input to tracking error) as a function
of frequency. Use this tuning goal for control system tuning with tuning commands such as
`systune`

or `looptune`

.

You can specify the maximum error profile directly by providing a transfer function. Alternatively, you can specify a target DC error, peak error, and response time. These parameters are converted to the following transfer function that describes the maximum frequency-domain tracking error:

$$\text{MaxError}=\frac{\left(\text{PeakError}\right)s+{\omega}_{c}\left(\text{DCError}\right)}{s+{\omega}_{c}}.$$

Here, *ω _{c}* is 2/(response time). The following plot
illustrates these relationships for an example set of values.

## Creation

### Syntax

### Description

creates a tuning goal `Req`

=
TuningGoal.Tracking(`inputname`

,`outputname`

,`responsetime`

,`dcerror`

,`peakerror`

)`Req`

that constrains the tracking performance from
`inputname`

to `outputname`

in the frequency domain.
This tuning goal specifies a maximum error profile as a function of frequency given by:

$$\text{MaxError}=\frac{\left(\text{PeakError}\right)s+{\omega}_{c}\left(\text{DCError}\right)}{s+{\omega}_{c}}.$$

The tracking bandwidth *ω _{c}* =
2/

`responsetime`

. The maximum relative steady-state error is given by
`dcerror`

, and `peakerror`

gives the peak relative
error across all frequencies.You can specify a MIMO tracking requirement by specifying signal names or a cell array of
multiple signal names for `inputname`

or `outputname`

.
For MIMO tracking requirements, use the `InputScaling`

property to help limit
cross-coupling. See Properties.

specifies the maximum relative error as a function of frequency. You can specify the target
error profile (maximum gain from reference signal to tracking error signal) as a smooth
transfer function. Alternatively, you can sketch a piecewise error profile using an
`Req`

= TuningGoal.Tracking(`inputname`

,`outputname`

,`maxerror`

)`frd`

model.

### Input Arguments

## Properties

## Examples

## Tips

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

`Input`

to`Output`

, 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*), where
*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.Tracking`

, *f*(*x*) is
given by:

$$f\left(x\right)={\Vert {W}_{F}\left(s\right)\left(T\left(s,x\right)-I\right)\Vert}_{\infty},$$

or its discrete-time equivalent. Here,
*T*(*s*,*x*) is the closed-loop transfer
function from `Input`

to `Output`

, and $${\Vert \text{\hspace{0.17em}}\cdot \text{\hspace{0.17em}}\Vert}_{\infty}$$ denotes the *H*_{∞} norm (see
`getPeakGain`

). *W _{F}* is a frequency weighting
function derived from the error profile you specify in the tuning goal. The gains of

*W*and

_{F}`1/MaxError`

roughly match
for gain values between –20 dB and 60 dB. For numerical reasons, the weighting function levels
off outside this range, unless you specify a reference model that changes slope outside this
range. This adjustment is called *regularization*. Because poles of

*W*close to

_{F}*s*= 0 or

*s*=

`Inf`

might lead to poor numeric conditioning of the
`systune`

optimization problem, it is not recommended to specify error
profiles with very low-frequency or very high-frequency dynamics.To obtain *W _{F}*, use:

WF = getWeight(Req,Ts)

where `Req`

is the tuning goal, and `Ts`

is the sample
time at which you are tuning (`Ts = 0`

for continuous time). For more
information about regularization and its effects, see Visualize Tuning Goals.

## Version History

**Introduced in R2016a**

## See Also

`looptune`

| `systune`

| `systune (for slTuner)`

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

(Simulink Control Design) | `viewGoal`

| `evalGoal`

| `TuningGoal.Gain`

| `TuningGoal.LoopShape`

| `slTuner`

(Simulink Control Design)