Complementary sensitivity function at specified point
using slLinearizer
or slTuner
interface
returns
the complementary
sensitivity function at the specified analysis point for the
model associated with the sys
= getCompSensitivity(s
,pt
)slLinearizer
or slTuner
interface, s
.
The software enforces all the permanent openings specified
for s
when it calculates sys
.
If you configured either s.Parameters
, or s.OperatingPoints
,
or both, getCompSensitivity
performs multiple
linearizations and returns an array of complementary sensitivity functions.
considers
additional, temporary, openings at the point specified by sys
= getCompSensitivity(s
,pt
,temp_opening
)temp_opening
.
Use an opening, for example, to calculate the complementary sensitivity
function of an inner loop with the outer loop open.
returns
a subset of the batch linearization results. sys
= getCompSensitivity(___,mdl_index
)mdl_index
specifies
the index of the linearizations of interest, in addition to any of
the input arguments in previous syntaxes.
Use this syntax for efficient linearization, when you want to obtain the complementary sensitivity function for only a subset of the batch linearization results.
Obtain the complementary sensitivity function, calculated at the plant output, for the ex_scd_simple_fdbk
model.
Open the ex_scd_simple_fdbk
model.
mdl = 'ex_scd_simple_fdbk';
open_system(mdl);
In this model:
Create an slLinearizer
interface for the model.
sllin = slLinearizer(mdl);
To calculate the complementary sensitivity function at the plant output, use the y
signal as the analysis point. Add this point to sllin
.
addPoint(sllin,'y');
Obtain the complementary sensitivity function at y
.
sys = getCompSensitivity(sllin,'y');
tf(sys)
ans = From input "y" to output "y": 3  s + 8 Continuoustime transfer function.
The software adds a linearization output at y
, followed by a linearization input, dy
.
sys
is the transfer function from dy
to y
, which is equal to
.
For the scdcascade
model, obtain the complementary sensitivity function for the innerloop at y2
.
Open the scdcascade
model.
mdl = 'scdcascade';
open_system(mdl);
Create an slLinearizer
interface for the model.
sllin = slLinearizer(mdl);
To calculate the complementary sensitivity transfer function for the inner loop at y2
, use the y2
signal as the analysis point. To eliminate the effects of the outer loop, break the outer loop at y1m
. Add both these points to sllin
.
addPoint(sllin,{'y2','y1m'});
Obtain the complementary sensitivity function for the inner loop at y2
.
sys = getCompSensitivity(sllin,'y2','y1m');
Here, 'y1m'
, the third input argument, specifies a temporary opening for the outer loop.
Suppose you batch linearize the scdcascade
model for multiple transfer functions. For most linearizations, you vary the proportional (Kp2
) and integral gain (Ki2
) of the C2
controller in the 10% range. For this example, calculate the complementary sensitivity function for the inner loop for the maximum value of Kp2
and Ki2
.
Open the scdcascade
model.
mdl = 'scdcascade';
open_system(mdl);
Create an slLinearizer
interface for the model.
sllin = slLinearizer(mdl);
Vary the proportional (Kp2
) and integral gain (Ki2
) of the C2
controller in the 10% range.
Kp2_range = linspace(0.9*Kp2,1.1*Kp2,3); Ki2_range = linspace(0.9*Ki2,1.1*Ki2,5); [Kp2_grid,Ki2_grid]=ndgrid(Kp2_range,Ki2_range); params(1).Name = 'Kp2'; params(1).Value = Kp2_grid; params(2).Name = 'Ki2'; params(2).Value = Ki2_grid; sllin.Parameters = params;
To calculate the complementary sensitivity of the inner loop, use the y2
signal as the analysis point. To eliminate the effects of the outer loop, break the outer loop at y1m
. Add both these points to sllin
.
addPoint(sllin,{'y2','y1m'})
Determine the index for the maximum values of Ki2
and Kp2
.
mdl_index = params(1).Value == max(Kp2_range) & params(2).Value == max(Ki2_range);
Obtain the complementary sensitivity transfer function at y2
.
sys = getCompSensitivity(sllin,'y2','y1m',mdl_index);
Open Simulink model.
mdl = 'watertank';
open_system(mdl)
Create a linearization option set and set the StoreOffsets
option.
opt = linearizeOptions('StoreOffsets',true);
Create slLinearizer
interface.
sllin = slLinearizer(mdl,opt);
Add an analysis point at the tank output port.
addPoint(sllin,'watertank/WaterTank System');
Calculate the complementary sensitivity function at y
, and obtain the corresponding linearization offsets.
[sys,info] = getCompSensitivity(sllin,'watertank/WaterTank System');
View offsets.
info.Offsets
ans = struct with fields: x: [2×1 double] dx: [2×1 double] u: 1 y: 1 StateName: {2×1 cell} InputName: {'watertank/WaterTank System'} OutputName: {'watertank/WaterTank System'} Ts: 0
s
— Interface to Simulink^{®} modelslLinearizer
interface  slTuner
interfaceInterface to a Simulink model, specified as either an slLinearizer
interface or an slTuner
interface.
pt
— Analysis point signal nameAnalysis point signal name, specified as:
Character vector — Analysis point signal name.
To determine the signal name associated with an analysis point,
type s
. The software displays the contents of s
in
the MATLAB^{®} command window, including the analysis point signal
names, block names, and port numbers. Suppose that an analysis point
does not have a signal name, but only a block name and port number.
You can specify pt
as the block name. To use
a point not in the list of analysis points for s
,
first add the point using addPoint
.
You can specify pt
as a uniquely matching
portion of the full signal name or block name. Suppose that the full
signal name of an analysis point is 'LoadTorque'
.
You can specify pt
as 'Torque'
as
long as 'Torque'
is not a portion of the signal
name for any other analysis point of s
.
For example, pt = 'y1m'
.
Cell array of character vectors — Specifies
multiple analysis point names. For example, pt = {'y1m','y2m'}
.
To calculate sys
, the software adds a linearization
output, followed by a linearization input at pt
.
Consider the following model:
Specify pt
as 'y'
:
The software computes sys
as the transfer
function from dy
to y
.
If you specify pt
as multiple signals,
for example pt = {'u','y'}
, the software adds a
linearization output, followed by a linearization input at each point.
du
and dy
are linearization
inputs, and u
and y
are linearization
outputs. The software computes sys
as a MIMO
transfer function with a transfer function from each linearization
input to each linearization output.
temp_opening
— Temporary opening signal nameTemporary opening signal name, specified as:
Character vector — Analysis point signal name.
temp_opening
must specify an analysis point
that is in the list of analysis points for s
.
To determine the signal name associated with an analysis point, type s
.
The software displays the contents of s
in the MATLAB command
window, including the analysis point signal names, block names, and
port numbers. Suppose that an analysis point does not have a signal
name, but only a block name and port number. You can specify temp_opening
as
the block name. To use a point not in the list of analysis points
for s
, first add the point using addPoint
.
You can specify temp_opening
as a uniquely
matching portion of the full signal name or block name. Suppose that
the full signal name of an analysis point is 'LoadTorque'
.
You can specify temp_opening
as 'Torque'
as
long as 'Torque'
is not a portion of the signal
name for any other analysis point of s
.
For example, temp_opening = 'y1m'
.
Cell array of character vectors — Specifies
multiple analysis point names. For example, temp_opening
= {'y1m','y2m'}
.
mdl_index
— Index for linearizations of interestIndex for linearizations of interest, specified as:
Array of logical values — Logical array index
of linearizations of interest. Suppose that you vary two parameters, par1
and par2
,
and want to extract the linearization for the combination of par1
> 0.5
and par2 <= 5
. Use:
params = s.Parameters; mdl_index = params(1).Value>0.5 & params(2).Value <= 5;
The expression params(1).Value>0.5 & params(2).Value<5
uses
logical indexing and returns a logical array. This logical array is
the same size as params(1).Value
and params(2).Value
.
Each entry contains the logical evaluation of the expression for corresponding
entries in params(1).Value
and params(2).Value
.
Vector of positive integers — Linear index
of linearizations of interest. Suppose that you vary two parameters, par1
and par2
,
and want to extract the linearization for the combination of par1
> 0.5
and par2 <= 5
. Use:
params = s.Parameters; mdl_index = find(params(1).Value>0.5 & params(2).Value <= 5);
The expression params(1).Value>0.5 & params(2).Value<5
returns
a logical array. find
returns
the linear index of every true entry in the logical array
sys
— Complementary sensitivity functionComplementary sensitivity function, returned as described in the following:
If you did not configure s.Parameters
and s.OperatingPoints
,
the software calculates sys
using the default
model parameter values. The software uses the model initial conditions
as the linearization operating point. sys
is
returned as a statespace model.
If you configured s.Parameters
only,
the software computes a linearization for each parameter grid point. sys
is
returned as a statespace model array of the same size as the parameter
grid.
If you configured s.OperatingPoints
only,
the software computes a linearization for each specified operating
point. sys
is returned as a statespace model
array of the same size as s.OperatingPoints
.
If you configured s.Parameters
and
specified s.OperatingPoints
as a single operating
point, the software computes a linearization for each parameter grid
point. The software uses the specified operating point as the linearization
operating point. sys
is returned as a statespace
model array of the same size as the parameter grid.
If you configured s.Parameters
and
specified s.OperatingPoints
as multiple operating
point objects, the software computes a linearization for each parameter
grid point. The software requires that s.OperatingPoints
is
the same size as the parameter grid specified by s.Parameters
.
The software computes each linearization using corresponding operating
points and parameter grid points. sys
is returned
as a statespace model array of the same size as the parameter grid.
If you configured s.Parameters
and
specified s.OperatingPoints
as multiple simulation
snapshot times, the software simulates and linearizes the model for
each snapshot time and parameter grid point combination. Suppose that
you specify a parameter grid of size p
and N
snapshot
times. sys
is returned as a statespace model
array of size N
byp
.
info
— Linearization informationLinearization information, returned as a structure with the following field:
Offsets
— Linearization offsets[]
(default)  structure  structure arrayLinearization offsets, returned as []
if s.Options.StoreOffsets
is false
.
Otherwise, Offsets
is returned as one of the following:
If s.OperatingPoints
is a single
operating point, Offsets
is a structure.
If s.OperatingPoints
is an array, Offsets
is
a structure array with the same dimensions as s.OperatingPoints
.
Each offset structure has the following fields:
Field  Description 

x  State offsets used for linearization, returned as a column
vector of length n_{x}, where n_{x} is
the number of states in sys . 
y  Output offsets used for linearization, returned as a column
vector of length n_{y}, where n_{y} is
the number of outputs in sys . 
u  Input offsets used for linearization, returned as a column
vector of length n_{u}, where n_{u} is
the number of inputs in sys . 
dx  Derivative offsets for continuous time systems, or updated state values for discretetime systems, returned as a column vector of length n_{x}. 
StateName  State names, returned as a cell array that contains n_{x} elements
that match the names in sys.StateName . 
InputName  Input names, returned as a cell array that contains n_{u} elements
that match the names in sys.InputName . 
OutputName  Output names, returned as a cell array that contains n_{y} elements
that match the names in sys.OutputName . 
Ts  Sample time of the linearized system, returned as a scalar
that matches the sample time in sys.Ts . For continuoustime
systems, Ts is 0 . 
If Offsets
is a structure array, you can
configure an LPV System block using
the offsets. To do so, first convert them to the required format using getOffsetsForLPV
. For an example, see Approximating Nonlinear Behavior using an Array of LTI Systems.
The complementary sensitivity function at a point is the transfer function from an additive disturbance at the point to a measurement at the same point. In contrast to the sensitivity function, the disturbance is added after the measurement.
To compute the complementary sensitivity function at an analysis
point, x
, the software adds a linearization output
at x
, followed by a linearization input, dx
.
The complementary sensitivity function is the transfer function from dx
to x
.
Analysis Point in Simulink Model  How getCompSensitivity Interprets
Analysis Point  Complementary Sensitivity Function 


 Transfer function from 
For example, consider the following model where you compute
the complementary sensitivity function at y
:
Here, the software adds a linearization output at y
,
followed by a linearization input, dy
. The complementary
sensitivity function at y
, T,
is the transfer function from dy
to y
. T is
calculated as follows:
$$\begin{array}{l}y=GK(y+dy)\\ \to y=GKyGKdy\\ \to (I+GK)y=GKdy\\ \to y=\underset{T}{\underbrace{{(I+GK)}^{1}GK}}dy.\end{array}$$
Here I is an identity matrix of the same
size as GK.
The complementary sensitivity transfer function at y
is
equal to 1
times the closedloop transfer function
from r
to y
.
Generally, the complementary sensitivity function, T,
computed from reference signals to plant outputs, is equal to I–S.
Here S is the sensitivity function at the point,
and I is the identity matrix of commensurate size.
However, because getCompSensitivity
adds
the linearization output and input at the same point, T,
as returned by getCompSensitivity
,
is equal to S–I.
The software does not modify the Simulink model when it computes the complementary sensitivity function.
Analysis points, used
by the slLinearizer
and slTuner
interfaces,
identify locations within a model that are relevant for linear analysis
and control system tuning. You use analysis points as inputs to the
linearization commands, such as getIOTransfer
, getLoopTransfer
, getSensitivity
, and getCompSensitivity
. As inputs to the
linearization commands, analysis points can specify any openloop
or closedloop transfer function in a model. You can also use analysis
points to specify design requirements when tuning control systems
using commands such as systune
.
Location refers to a specific block output port within a model or to a bus element in such an output port. For convenience, you can use the name of the signal that originates from this port to refer to an analysis point.
You can add analysis points to an slLinearizer
or slTuner
interface, s
,
when you create the interface. For example:
s = slLinearizer('scdcascade',{'u1','y1'});
Alternatively, you can use the addPoint
command.
To view all the analysis points of s
, type s
at
the command prompt to display the interface contents. For each analysis
point of s
, the display includes the block name
and port number and the name of the signal that originates at this
point. You can also programmatically obtain a list of all the analysis
points using getPoints
.
For more information about how you can use analysis points, see Marking Signals of Interest for Control System Analysis and Design.
Permanent openings,
used by the slLinearizer
and slTuner
interfaces,
identify locations within a model where the software breaks the signal
flow. The software enforces these openings for linearization and tuning.
Use permanent openings to isolate a specific model component. Suppose
that you have a largescale model capturing aircraft dynamics and
you want to perform linear analysis on the airframe only. You can
use permanent openings to exclude all other components of the model.
Another example is when you have cascaded loops within your model
and you want to analyze a specific loop.
Location refers to a specific block output port within a model. For convenience, you can use the name of the signal that originates from this port to refer to an opening.
You can add permanent openings to an slLinearizer
or slTuner
interface, s
,
when you create the interface or by using the addOpening
command. To remove a location
from the list of permanent openings, use the removeOpening
command.
To view all the openings of s
, type s
at
the command prompt to display the interface contents. For each permanent
opening of s
, the display includes the block name
and port number and the name of the signal that originates at this
location. You can also programmatically obtain a list of all the permanent
loop openings using getOpenings
.
addOpening
 addPoint
 getIOTransfer
 getLoopTransfer
 getSensitivity
 slLinearizer
 slTuner
You clicked a link that corresponds to this MATLAB command:
Run the command by entering it in the MATLAB Command Window. Web browsers do not support MATLAB commands.
You can also select a location from the following list: