# TuningGoal.Gain

Gain constraint for control system tuning

## Description

Use the `TuningGoal.Gain`

object to specify a
constraint that limits the gain from a specified input to a specified output. Use this tuning
goal for control system tuning with tuning commands such as `systune`

or
`looptune`

.

When you use `TuningGoal.Gain`

, the software attempts to
tune the system so that the gain from the specified input to the specified output does not exceed
the specified value. By default, the constraint is applied with the loop closed. To apply the
constraint to an open-loop response, use the `Openings`

property of the `TuningGoal.Gain`

object.

You can use a gain constraint to:

Enforce a design requirement of disturbance rejection across a particular input/output pair, by constraining the gain to be less than 1

Enforce a custom roll-off rate in a particular frequency band, by specifying a gain profile in that band

## Creation

### Syntax

### Description

creates a tuning goal that constrains the gain from `Req`

=
TuningGoal.Gain(`inputname`

,`outputname`

,`gainvalue`

)`inputname`

to
`outputname`

to remain below the value `gainvalue`

.

You can specify the `inputname`

or `outputname`

as
cell arrays (vector-valued signals). If you do so, then the tuning goal constrains the largest
singular value of the transfer matrix from `inputname`

to
`outputname`

. See `sigma`

for more information about singular values.

specifies the maximum gain as a function of frequency. You can specify the target gain profile
(maximum gain across the I/O pair) as a smooth transfer function. Alternatively, you can
sketch a piecewise error profile using an `Req`

= TuningGoal.Gain(`inputname`

,`outputname`

,`gainprofile`

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

object, 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.Gain`

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

$$f\left(x\right)={\Vert {W}_{F}\left(s\right){D}_{o}^{-1}T\left(s,x\right){D}_{i}\Vert}_{\infty},$$

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

to `Output`

.
*D _{o}* and

*D*are diagonal matrices with the

_{i}`OutputScaling`

and
`InputScaling`

property values on the diagonal, respectively. $${\Vert \text{\hspace{0.17em}}\cdot \text{\hspace{0.17em}}\Vert}_{\infty}$$ denotes the *H*

_{∞}norm (see

`getPeakGain`

). The frequency weighting function *W _{F}* is the
regularized gain profile, derived from the maximum gain profile you specify. The gains of

*W*and

_{F}`1/MaxGain`

roughly match
inside the frequency band `Focus`

. *W*is always stable and proper. Because poles of

_{F}*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 maximum gain 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`

| `viewGoal`

| `systune`

| `systune (for slTuner)`

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

(Simulink Control Design) | `TuningGoal.Tracking`

| `TuningGoal.LoopShape`

| `slTuner`

(Simulink Control Design) | `makeweight`

(Robust Control Toolbox)