# TuningGoal.Overshoot

Overshoot constraint for control system tuning

## Description

Use `TuningGoal.Overshoot`

to limit the overshoot in
the step response from specified inputs to specified outputs of a control system. Use this tuning
goal for control system tuning with tuning commands such as `systune`

or
`looptune`

.

## Creation

### Description

creates a tuning goal for limiting the overshoot in the step response between the specified
signal locations. The scalar `Req`

= TuningGoal.Overshoot(`inputname`

,`outputname`

,`maxpercent`

)`maxpercent`

specifies the maximum overshoot
as a percentage.

When you use `TuningGoal.Overshoot`

for tuning, the
software maps overshoot constraints to peak gain constraints assuming second-order system
characteristics. Therefore, the mapping is only approximate for higher-order systems. In
addition, this tuning goal cannot reliably reduce the overshoot below 5%.

### 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*).
*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.Overshoot`

,
*f*(*x*) reflects the relative satisfaction or violation of
the goal. The percent deviation from *f*(*x*) = 1 roughly
corresponds to the percent deviation from the specified overshoot target. For example,
*f*(*x*) = 1.2 means the actual overshoot exceeds the target
by roughly 20%, and *f*(*x*) = 0.8 means the actual overshoot
is about 20% less than the target.

`TuningGoal.Overshoot`

uses $${\Vert T\Vert}_{\infty}$$ as a proxy for the overshoot, based on second-order model characteristics.
Here, *T* is the closed-loop transfer function that the tuning goal constrains.
The overshoot is tuned in the range from 5% ($${\Vert T\Vert}_{\infty}$$ = 1) to 100% ($${\Vert T\Vert}_{\infty}$$). `TuningGoal.Overshoot`

is ineffective at
forcing the overshoot below 5%.

## 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.Sensitivity`

| `slTuner`

(Simulink Control Design)