TuningGoal.Overshoot class

Package: TuningGoal

Overshoot constraint for control system tuning

Description

Use the `TuningGoal.Overshoot` object to limit the overshoot in the step response from specified inputs to specified outputs of a control system. Use this requirement for control system tuning with tuning commands such as `systune` or `looptune`.

Construction

`Req = TuningGoal.Overshoot(inputname,outputname,maxpercent)` creates a tuning requirement for limiting the overshoot in the step response between the specified signal locations. The scalar `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 requirement cannot reliably reduce the overshoot below 5%.

Input Arguments

 `inputname` Input signals for the requirement, specified as a string or as a cell array of strings, for multiple-input requirements. If you are using the requirement to tune a Simulink® model of a control system, then `inputname` can include: Any model input.Any linear analysis point marked in the model.Any linear analysis point in an `slTuner` interface associated with the Simulink model. Use `addPoint` to add analysis points to the `slTuner` interface. Use `getPoints` to get the list of analysis points available in an `slTuner` interface to your model. If you are using the requirement to tune a generalized state-space (`genss`) model of a control system, then `inputname` can include: Any input of the `genss` model Any `AnalysisPoint` location in the control system model For example, if you are tuning a control system model, `T`, then `inputname` can be a string contained in `T.InputName`. Also, if `T` contains an `AnalysisPoint` block with a location named `AP_u`, then `inputname` can include `'AP_u'`. Use `getPoints` to get a list of analysis points available in a `genss` model. If `inputname` is an `AnalysisPoint` location of a generalized model, the input signal for the requirement is the implied input associated with the `AnalysisPoint` block: For more information about analysis points in control system models, see Marking Signals of Interest for Control System Analysis and Design. `outputname` Output signals for the requirement, specified as a string or as a cell array of strings, for multiple-output requirements. If you are using the requirement to tune a Simulink model of a control system, then `outputname` can include: Any model output.Any linear analysis point marked in the model.Any linear analysis point in an `slTuner` interface associated with the Simulink model. Use `addPoint` to add analysis points to the `slTuner` interface. Use `getPoints` to get the list of analysis points available in an `slTuner` interface to your model. If you are using the requirement to tune a generalized state-space (`genss`) model of a control system, then `outputname` can include: Any output of the `genss` model Any `AnalysisPoint` location in the control system model For example, if you are tuning a control system model, `T`, then `inputname` can be a string contained in `T.OutputName`. Also, if `T` contains an `AnalysisPoint` block with a location named `AP_y`, then `inputname` can include `'AP_y'`. Use `getPoints` to get a list of analysis points available in a `genss` model. If `outputname` is an `AnalysisPoint` location of a generalized model, the output signal for the requirement is the implied output associated with the `AnalysisPoint` block: For more information about analysis points in control system models, see Marking Signals of Interest for Control System Analysis and Design. `maxpercent` Maximum percent overshoot, specified as a scalar value. For example, the following code specifies a maximum 5% overshoot in the step response from `'r'` to `'y'`. `Req = TuningGoal.Overshoot('r','y',5);` `TuningGoal.OverShoot` cannot reliably reduce the overshoot below 5%.

Properties

 `MaxOvershoot` Maximum percent overshoot, specified as a scalar value. For example, the scalar value 5 means the overshoot should not exceed 5%. The initial value of the `MaxOvershoot` property is set by the `maxpercent` input argument when you construct the requirement object. `InputScaling` Reference signal scaling, specified as a vector of positive real values. For a MIMO tuning requirement, when the choice of units results in a mix of small and large signals in different channels of the response, use this property to specify the relative amplitude of each entry in the vector-valued step input. This information is used to scale the off-diagonal terms in the transfer function from reference to tracking error. This scaling ensures that cross-couplings are measured relative to the amplitude of each reference signal. For example, suppose that `Req` is a requirement that signals `{'y1','y2'}` track reference signals `{'r1','r2'}`. Suppose further that you require the outputs to track the references with less than 10% cross-coupling. If `r1` and `r2` have comparable amplitudes, then it is sufficient to keep the gains from `r1` to `y2` and `r2` and `y1` below 0.1. However, if `r1` is 100 times larger than `r2`, the gain from `r1` to `y2` must be less than 0.001 to ensure that `r1` changes `y2` by less than 10% of the `r2` target. To ensure this result, set the `InputScaling` property as follows. `Req.InputScaling = [100,1];` This tells the software to take into account that the first reference signal is 100 times greater than the second reference signal. The default value, `[]` , means no scaling. Default: `[]` `Input` Input signal names, specified as a cell array of strings. These strings specify the names of the inputs of the transfer function that the tuning requirement constrains. The initial value of the `Input` property is set by the `inputname` input argument when you construct the requirement object. `Output` Output signal names, specified as a cell array of strings. These strings specify the names of the outputs of the transfer function that the tuning requirement constrains. The initial value of the `Output` property is set by the `outputname` input argument when you construct the requirement object. `Models` Models to which the tuning requirement 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 requirement for a subset of models in the array. For example, suppose you want to apply the tuning requirement, `Req`, to the second, third, and fourth models in a model array passed to `systune`. To restrict enforcement of the requirement, use the following command: `Req.Models = 2:4;` When `Models = NaN`, the tuning requirement applies to all models. Default: `NaN` `Openings` Feedback loops to open when evaluating the requirement, specified as a cell array of strings that identify loop-opening locations. The tuning requirement is evaluated against the open-loop configuration created by opening feedback loops at the locations you identify. If you are using the requirement 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` interface associated with the Simulink model. Use `addPoint` to add analysis points and loop openings to the `slTuner` interface. Use `getPoints` to get the list of analysis points available in an `slTuner` interface to your model. If you are using the requirement 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. Default: `{}` `Name` Name of the requirement object, specified as a string. For example, if `Req` is a requirement: `Req.Name = 'LoopReq';` Default: `[]`

Examples

collapse all

Overshoot Constraint

Create a requirement that limits the overshoot of the step response from signals named `'r'` to `'y'` in a control system to 8 percent.

```Req = TuningGoal.Overshoot('r','y',8); ```

You can use `Req` as an input to `looptune` or `systune` when tuning the control system.

Configure the requirement to apply only to the second model in a model array to tune. Also, configure the requirement to be evaluated with a loop open in the control system.

```Req.Models = 2; Req.Openings = 'OuterLoop'; ```

Setting the `Models` property restricts application of the requirement to the second model in an array, when you use the requirement to tune an array of control system models. Setting the `Openings` property specifies that requirement is evaluated with a loop opened at the location in the control system identified by `'OuterLoop'`.

Algorithms

When you use a `TuningGoal` object to specify a tuning requirement, the software converts the requirement 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 requirement 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 ${‖T‖}_{\infty }$ as a proxy for the overshoot, based on second-order model characteristics. Here, T is the closed-loop transfer function that the requirement constrains. The overshoot is tuned in the range from 5% (${‖T‖}_{\infty }$ = 1) to 100% (${‖T‖}_{\infty }$). `TuningGoal.Overshoot` is ineffective at forcing the overshoot below 5%.