# TuningGoal.ConicSector

Sector bound for control system tuning

## Description

Use `TuningGoal.ConicSector` to create a conic sector bound for control system tuning.

A conic sector bound is a restriction on the output trajectories of a system. If for all nonzero input trajectories u(t), the output trajectory z(t) = (Hu)(t) of a linear system H satisfies:

`${\int }_{0}^{T}z{\left(t\right)}^{\text{T}}Q\text{\hspace{0.17em}}z\left(t\right)dt<0,$`

for all T ≥ 0, then the output trajectories of H lie in the conic sector described by the symmetric indefinite matrix Q. Selecting different Q matrices imposes different conditions on the system response.

When tuning a control system with `systune`, use `TuningGoal.ConicSector` to restrict the output trajectories of the response between specified inputs and outputs to a specified sector. For more information about sector bounds, see About Sector Bounds and Sector Indices.

## Creation

### Syntax

``Req = TuningGoal.ConicSector(inputname,outputname,Q)``

### Description

example

````Req = TuningGoal.ConicSector(inputname,outputname,Q)` creates a tuning goal for restricting the response H(s) from inputs `inputname` to outputs `outputname` to the conic sector specified by the symmetric matrix `Q`. The tuning goal constrains H such that its trajectories z(t) = (Hu)(t) satisfy: ${\int }_{0}^{T}z{\left(t\right)}^{\text{T}}Q\text{\hspace{0.17em}}z\left(t\right)dt<0,$for all T ≥ 0. (See About Sector Bounds and Sector Indices.) The matrix `Q` must have as many negative eigenvalues as there are inputs in H.To specify frequency-dependent sector bounds, set `Q` to an LTI model that satisfies Q(s)T = Q(–s). ```

### Input Arguments

expand all

Input signals for the tuning goal, specified as a character vector or, for multiple-input tuning goals, a cell array of character vectors.

• If you are using the tuning goal 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` (Simulink Control Design) interface associated with the Simulink model. Use `addPoint` (Simulink Control Design) to add analysis points to the `slTuner` interface. Use `getPoints` (Simulink Control Design) to get the list of analysis points available in an `slTuner` interface to your model.

For example, suppose that the `slTuner` interface contains analysis points `u1` and `u2`. Use `'u1'` to designate that point as an input signal when creating tuning goals. Use `{'u1','u2'}` to designate a two-channel input.

• If you are using the tuning goal to tune a generalized state-space (`genss`) model of a control system, then `inputname` can include:

For example, if you are tuning a control system model, `T`, then `inputname` can be any input name 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 tuning goal is the implied input associated with the `AnalysisPoint` block:

For more information about analysis points in control system models, see Mark Signals of Interest for Control System Analysis and Design.

Output signals for the tuning goal, specified as a character vector or, for multiple-output tuning goals, a cell array of character vectors.

• If you are using the tuning goal 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` (Simulink Control Design) interface associated with the Simulink model. Use `addPoint` (Simulink Control Design) to add analysis points to the `slTuner` interface. Use `getPoints` (Simulink Control Design) to get the list of analysis points available in an `slTuner` interface to your model.

For example, suppose that the `slTuner` interface contains analysis points `y1` and `y2`. Use `'y1'` to designate that point as an output signal when creating tuning goals. Use `{'y1','y2'}` to designate a two-channel output.

• If you are using the tuning goal to tune a generalized state-space (`genss`) model of a control system, then `outputname` can include:

For example, if you are tuning a control system model, `T`, then `outputname` can be any output name in `T.OutputName`. Also, if `T` contains an `AnalysisPoint` block with a location named `AP_u`, then `outputname` can include `'AP_u'`. 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 tuning goal is the implied output associated with the `AnalysisPoint` block:

For more information about analysis points in control system models, see Mark Signals of Interest for Control System Analysis and Design.

Sector geometry, specified as:

• A matrix, for constant sector geometry. `Q` is a symmetric square matrix that is `ny` on a side, where `ny` is the number of signals in `outputname`. The matrix `Q` must be indefinite to describe a well-defined conic sector. An indefinite matrix has both positive and negative eigenvalues. In particular, `Q` must have as many negative eigenvalues as there are input channels specified in `inputname` (the size of the vector input signal u(t)).

• An LTI model, for frequency-dependent sector geometry. `Q` satisfies Q(s)T = Q(–s). In other words, Q(s) evaluates to a Hermitian matrix at each frequency.

## Properties

expand all

Sector geometry, specified as a matrix or an LTI model. The `Q` input argument sets initial value of `SectorMatrix` when you create the tuning goal, and the same restrictions and characteristics apply to `SectorMatrix` as apply to `Q`.

Regularization parameter, specified as a real nonnegative scalar value.

Given the indefinite factorization of the sector matrix,

`$Q={W}_{1}{W}_{1}^{\text{T}}-{W}_{2}{W}_{2}^{\text{T}},\text{ }{W}_{1}^{\text{T}}{W}_{2}=0$`

the sector bound

`$H{\left(-j\omega \right)}^{\text{T}}Q\text{\hspace{0.17em}}H\left(j\omega \right)\text{\hspace{0.17em}}\text{\hspace{0.17em}}<\text{\hspace{0.17em}}\text{\hspace{0.17em}}0$`

is equivalent to

`${H}_{1}{\left(j\omega \right)}^{\text{H}}{H}_{1}\left(j\omega \right)<{H}_{2}{\left(j\omega \right)}^{\text{H}}{H}_{2}\left(j\omega \right),$`

where ${H}_{1}={W}_{1}^{\text{T}}H$, ${H}_{2}={W}_{2}^{\text{T}}H$, and (•)H denotes the Hermitian transpose. Enforcing this condition might become numerically challenging when other tuning goals drive both H1() and H2() to zero at some frequencies. This condition is equivalent to controlling the sign of a 0/0 expression, which is intractable in the presence of rounding errors. To avoid this condition, you can regularize the sector bound to

`$H{\left(-j\omega \right)}^{\text{T}}Q\text{\hspace{0.17em}}H\left(j\omega \right)\text{\hspace{0.17em}}\text{\hspace{0.17em}}<\text{\hspace{0.17em}}\text{\hspace{0.17em}}-{\epsilon }^{2}I,$`

or equivalently,

`${H}_{1}{\left(j\omega \right)}^{\text{H}}{H}_{1}\left(j\omega \right)+{\epsilon }^{2}I<{H}_{2}{\left(j\omega \right)}^{\text{H}}{H}_{2}\left(j\omega \right).$`

This regularization prevents H2() from becoming singular, and helps keep evaluation of the tuning goal numerically tractable. Use the `Regularization` property to set the value of ε to a small (but not negligible) fraction of the typical norm of the feedthrough term in H. For example, if you anticipate the norm of the feedthrough term of H to be of order 1 during tuning, try:

`Req.Regularization = 1e-3;`

Frequency band in which tuning goal is enforced, specified as a row vector of the form `[min,max]`. For continuous time, the default value is equal to `[0,Inf]`. For discrete time, the default value is equal to `[0,pi/Ts]`, where `Ts` is the model sample time.

Set the `Focus` property to limit enforcement of the tuning goal to a particular frequency band. Express this value in the frequency units of the control system model you are tuning (rad/`TimeUnit`). For example, suppose `Req` is a tuning goal that you want to apply only between 1 and 100 rad/s. To restrict the tuning goal to this band, use the following command:

`Req.Focus = [1,100];`

Input signal names, specified as a cell array of character vectors. The input signal names specify the inputs of the constrained response, initially populated by the `inputname` argument.

Output signal names, specified as a cell array of character vectors. The output signal names specify the outputs of the constrained response, initially populated by the `outputname` argument.

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.

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

Name of the tuning goal, specified as a character vector.

For example, if `Req` is a tuning goal:

`Req.Name = 'LoopReq';`

## Examples

collapse all

Create a tuning goal that restricts the response from an input or analysis point `'u'` to an output or analysis point `'y'` in a control system to the following sector:

`$S=\left\{\left(y,u\right):0.1{u}^{2}`

The Q matrix for this sector is given by:

```a = 0.1; b = 10; Q = [1 -(a+b)/2 ; -(a+b)/2 a*b];```

Use this Q matrix to create the tuning goal.

`TG = TuningGoal.ConicSector('u','y',Q)`
```TG = ConicSector with properties: SectorMatrix: [2x2 double] Regularization: 0 Focus: [0 Inf] Input: {'u'} Output: {'y'} Models: NaN Openings: {0x1 cell} Name: '' ```

Set properties to further configure the tuning goal. For example, suppose the control system model has an analysis point called `'OuterLoop'`, and you want to enforce the tuning goal with the loop open at that point.

`TG.Openings = 'OuterLoop';`

Before or after tuning, use `viewGoal` to visualize the tuning goal.

`viewGoal(TG)`

The goal is met when the relative sector index R < 1 at all frequencies. The shaded area represents the region where the goal is not met. When you use this requirement to tune a control system `CL`, `viewGoal(TG,CL)` shows R for the specified inputs and outputs on this plot, enabling you to identify frequency ranges in which the goal is not met, and by how much.

Consider the following control system.

Suppose that the signal u is marked as an analysis point in a Simulink model or `genss` model of the control system. Suppose also that G is the closed-loop transfer function from u to y. Create a tuning goal that constrains all I/O trajectories {u(t),y(t)} of G to satisfy:

`${\int }_{0}^{T}{\left(\begin{array}{c}y\left(t\right)\\ u\left(t\right)\end{array}\right)}^{T}Q\phantom{\rule{0.2777777777777778em}{0ex}}\left(\begin{array}{c}y\left(t\right)\\ u\left(t\right)\end{array}\right)dt<0,$`

for all $T\ge 0$. For this example, use sector matrix that imposes input passivity with index 0.5.

```nu = 0.5; Q = [0 -1;-1 2*nu];```

Constraining the I/O trajectories of G is equivalent to restricting the output trajectories $z\left(t\right)$ of $H=\left[G;I\right]$ to the sector defined by:

`${\int }_{0}^{T}z{\left(t\right)}^{T}Q\phantom{\rule{0.2777777777777778em}{0ex}}z\left(t\right)dt<0.$`

(See About Sector Bounds and Sector Indices for more details about this equivalence.) To specify this constraint, create a tuning goal that constrains the transfer function $H=\left[G;I\right]$, which the transfer function from input $u$ to outputs $\left\{y;u\right\}$.

`TG = TuningGoal.ConicSector('u',{'y';'u'},Q);`

When you specify the same signal `'u'` as both input and output, the conic sector tuning goal sets the corresponding transfer function to the identity. Therefore, the transfer function constrained by `TG` is $H=\left[G;I\right]$ as intended. This treatment is specific to the conic sector tuning goal. For other tuning goals, when the same signal appears in both inputs and outputs, the resulting transfer function is zero in the absence of feedback loops, or the complementary sensitivity at that location otherwise. This result occurs because when the software processes analysis points, it assumes the input is injected after the output. See Mark Signals of Interest for Control System Analysis and Design for more information about how analysis points work.

## Tips

• The conic sector tuning goal requires that ${W}_{2}^{\text{T}}H\left(s\right)$ be square and minimum phase, where H(s) is the transfer function between the specified inputs and outputs, and W2 spans the negative invariant subspace of the sector matrix, Q:

`$Q={W}_{1}{W}_{1}^{\text{T}}-{W}_{2}{W}_{2}^{\text{T}},\text{ }{W}_{1}^{\text{T}}{W}_{2}=0$`

(See Algorithms.) This means that the stabilized dynamics for this goal are not the poles of H, but rather the transmission zeros of ${W}_{2}^{\text{T}}H\left(s\right)$. 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

Let

`$Q={W}_{1}{W}_{1}^{\text{T}}-{W}_{2}{W}_{2}^{\text{T}},\text{ }{W}_{1}^{\text{T}}{W}_{2}=0$`

be an indefinite factorization of Q. When ${W}_{2}^{\text{T}}H\left(s\right)$ is square and minimum phase, then the time-domain sector bound on trajectories z(t) = Hu(t),

`${\int }_{0}^{T}z{\left(t\right)}^{\text{T}}Q\text{\hspace{0.17em}}z\left(t\right)dt<0,$`

is equivalent to the frequency-domain sector condition,

`$H{\left(-j\omega \right)}^{\text{T}}Q\text{\hspace{0.17em}}H\left(j\omega \right)\text{\hspace{0.17em}}\text{\hspace{0.17em}}<\text{\hspace{0.17em}}\text{\hspace{0.17em}}0$`

for all frequencies. The `TuningGoal.ConicSector` goal uses this equivalence to convert the time-domain characterization into a frequency-domain condition that `systune` can handle in the same way it handles gain constraints. To secure this equivalence, `TuningGoal.ConicSector` also makes ${W}_{2}^{\text{T}}H\left(s\right)$ minimum phase by making all its zeros stable.

For sector bounds, the R-index plays the same role as the peak gain does for gain constraints (see About Sector Bounds and Sector Indices). The condition

`$H{\left(-j\omega \right)}^{\text{T}}Q\text{\hspace{0.17em}}H\left(j\omega \right)\text{\hspace{0.17em}}\text{\hspace{0.17em}}<\text{\hspace{0.17em}}\text{\hspace{0.17em}}0$`

is satisfied at all frequencies if and only if the R-index is less than one. The `viewGoal` plot for `TuningGoal.ConicSector` shows the R-index value as a function of frequency (see `sectorplot`).

When you tune a control system using a `TuningGoal` object to specify a tuning goal, 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 the sector bound

`$H{\left(-j\omega \right)}^{\text{T}}Q\text{\hspace{0.17em}}H\left(j\omega \right)\text{\hspace{0.17em}}\text{\hspace{0.17em}}<\text{\hspace{0.17em}}\text{\hspace{0.17em}}0$`

`TuningGoal.ConicSector` uses the objective function given by:

`$f\left(x\right)=\frac{R}{1+R/{R}_{\mathrm{max}}},\text{ }{R}_{\mathrm{max}}={10}^{6}.$`

R is the sector-bound R-index (see `getSectorIndex` for details).

The dynamics of H affected by the minimum-phase condition 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.

## Version History

Introduced in R2016b