Transfer function for specified I/O set using slLinearizer
or slTuner
interface
returns
the transfer function
for the specified inputs and outputs for the model associated
with the sys
= getIOTransfer(s
,in
,out
)slLinearizer
or slTuner
interface, s
.
The software enforces all the permanent openings specified for s
when
it calculates sys
. For information on how getIOTransfer
treats in
and out
,
see Transfer Functions. If you configured
either s.Parameters
, or s.OperatingPoints
,
or both, getIOTransfer
performs multiple linearizations
and returns an array of transfer functions.
returns
the transfer function for the inputs and outputs specified by sys
= getIOTransfer(s
,ios
)ios
for
the model associated with s
. Use the linio
command
to create ios
. The software enforces the linearization
I/O type of each signal specified in ios
when
it calculates sys
. The software also enforces
all the permanent loop openings specified for s
.
returns
a subset of the batch linearization results. sys
= getIOTransfer(___,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 transfer function for only a subset of the batch linearization results.
Obtain the closedloop transfer function from
the reference signal, r
, to the plant output, y
,
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:
$$\begin{array}{l}K(s)={K}_{p}=3\\ G(s)=\frac{1}{s+5}.\end{array}$$
Create an slLinearizer
interface for
the model.
sllin = slLinearizer(mdl);
To obtain the closedloop transfer function from the reference
signal, r
, to the plant output, y
,
add both points to sllin
.
addPoint(sllin,{'r','y'});
Obtain the closedloop transfer function from r
to y
.
sys = getIOTransfer(sllin,'r','y'); tf(sys)
ans = From input "r" to output "y": 3  s + 8 Continuoustime transfer function.
The software adds a linearization input at r
, dr
,
and a linearization output at y
.
sys
is the transfer function from dr
to y
,
which is equal to (I+GK)^{1}GK.
Obtain the plant model transfer function, G
,
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:
$$\begin{array}{l}K(s)={K}_{p}=3\\ G(s)=\frac{1}{s+5}.\end{array}$$
Create an slLinearizer
interface for
the model.
sllin = slLinearizer(mdl);
To obtain the plant model transfer function, use u
as
the input point and y
as the output point. To eliminate
the effects of feedback, you must break the loop. You can break the
loop at u
, e
, or y
.
For this example, break the loop at u
. Add these
points to sllin
.
addPoint(sllin,{'u','y'});
Obtain the plant model transfer function.
sys = getIOTransfer(sllin,'u','y','u'); tf(sys)
ans = From input "u" to output "y": 1  s + 5 Continuoustime transfer function.
The second input argument specifies u
as
the input, while the fourth input argument specifies u
as
a temporary loop opening.
sys
is the transfer function from du
to y
,
which is equal to G.
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 openloop response transfer function for the
inner loop, from e2
to y2
, 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 openloop transfer function for the inner
loop, use e2
and y2
as analysis
points. To eliminate the effects of the outer loop, break the loop
at e2
. Add e2
and y2
to sllin
as
analysis points.
addPoint(sllin,{'e2','y2'})
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 openloop transfer function from e2
to y2
.
sys = getIOTransfer(sllin,'e2','y2','e2',mdl_index);
s
— Interface to Simulink^{®} modelslLinearizer
interface  slTuner
interfaceInterface to a Simulink model, specified as either an slLinearizer
interface or an slTuner
interface.
in
— Input analysis point signal namestring  cell array of stringsInput analysis point signal name, specified as:
String — 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 an analysis point does
not have a signal name, but only a block name and port number. You
can specify in
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 in
as a uniquely matching
substring of the full signal name or block name. Suppose the full
signal name of an analysis point is 'LoadTorque'
.
You can specify in
as 'Torque'
as
long as 'Torque'
is not a substring of the signal
name for any other analysis point of s
.
For example, in = 'y1m'
.
Cell array of strings — Specifies multiple
analysis point names. For example, in = {'y1m','y2m'}
.
out
— Output analysis point signal namestring  cell array of stringsOutput analysis point signal name, specified as:
String — 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 an analysis point does
not have a signal name, but only a block name and port number. You
can specify out
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 out
as a uniquely matching
substring of the full signal name or block name. Suppose the full
signal name of an analysis point is 'LoadTorque'
.
You can specify out
as 'Torque'
as
long as 'Torque'
is not a substring of the signal
name for any other analysis point of s
.
For example, out = 'y1m'
.
Cell array of strings — Specifies multiple
analysis point names. For example, out = {'y1m','y2m'}
.
temp_opening
— Temporary opening signal namestring  cell array of stringsTemporary opening signal name, specified as:
String — 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 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 substring of the full signal name or block name. Suppose
the full signal name of an analysis point is 'LoadTorque'
.
You can specify temp_opening
as 'Torque'
as
long as 'Torque'
is not a substring of the signal
name for any other analysis point of s
.
For example, temp_opening = 'y1m'
.
Cell array of strings — Specifies multiple
analysis point names. For example, temp_opening = {'y1m','y2m'}
.
ios
— Linearization I/Oslinearization I/O objectLinearization I/Os, created using linio
,
specified as a linearization I/O object.
ios
must specify signals that are in the
list of analysis points for s
. To view the list
of analysis points, type s
. To use a point that
is not in the list of analysis points for s
,
you must first add the point to the list using addPoint
.
For example:
ios(1) = linio('scdcascade/setpoint',1,'input'); ios(2) = linio('scdcascade/Sum',1,'output');
Here, ios(1)
specifies an input, and ios(2)
specifies
an output.
mdl_index
— Index for linearizations of interestarray of logical values  vector of positive integersIndex for linearizations of interest, specified as:
Array of logical values — Logical array index
of linearizations of interest. Suppose 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 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
— Transfer function for specified I/Osstatespace modelTransfer function for specified I/Os, returned as described below:
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 you
specify a parameter grid of size p
and N
snapshot
times. sys
is returned as a statespace model
array of size N
byp
.
A transfer function is an LTI system's response at a linearization output point to a linearization input. You perform linear analysis on transfer functions to understand the stability, timedomain or frequencydomain characteristics of a system.
You can calculate multiple transfer functions for a given block
diagram. Consider the ex_scd_simple_fdbk
model:
You can calculate the transfer function from the reference input
signal to the plant output signal. The reference input (also
referred to as setpoint) , r
,
originates at the Reference block, and the plant
output, y
, originates at the G block.
This transfer function is also called the overall closedloop transfer
function. To calculate this transfer function, the software adds a
linearization input at r
, dr
,
and a linearization output at y
.
The software calculates the overall closedloop transfer function
as the transfer function from dr
to y
,
which is equal to (I+GK)^{1}GK.
Observe that the transfer function from r
to y
is
equal to the transfer function from dr
to y
.
You can calculate the plant transfer function from
the plant input, u
, to the plant output, y
.
To isolate the plant dynamics from the effects of the feedback loop,
introduce a loop break (or opening) at y
, e
,
or, as shown, at u
.
The software breaks the loop and adds a linearization input, du
,
at u
, and a linearization output at y
.
The plant transfer function is equal to the transfer function from du
to y
,
which is G.
Similarly, to obtain the controller transfer function,
calculate the transfer function from the controller input, e
,
to the controller output, u
. Break the feedback
loop at y
, e
, or u
.
You can use getIOTransfer
to obtain a variety
of openloop and closedloop transfer functions. To configure the
transfer function, specify analysis points as inputs, outputs,
and openings (temporary or permanent), in any combination. The
software treats each combination uniquely. Consider the following
code that shows some different ways that you can use the analysis
point, u
, to obtain a transfer function:
sllin = slLinearizer('ex_scd_simple_fdbk') addPoint(sllin,{'u','e','y'}) T0 = getIOTransfer(sllin,'e','y','u'); T1 = getIOTransfer(sllin,'u','y'); T2 = getIOTransfer(sllin,'u','y','u'); T3 = getIOTransfer(sllin,'y','u'); T4 = getIOTransfer(sllin,'y','u','u'); T5 = getIOTransfer(sllin,'u','u'); T6 = getIOTransfer(sllin,'u','u','u');
In T0
, u
specifies a loop
break. In T1
, u
specifies only
an input, whereas in T2
, u
specifies
an input and an opening, also referred to as an openloop
input. In T3
, u
specifies
only an output, whereas in T4
, u
specifies
an output and an opening, also referred to as an openloop
output. In T5
, u
specifies
an input and an output, also referred to as a complementary
sensitivity point. In T6
, u
specifies
an input, an output, and an opening, also referred to as a loop
transfer point. The table describes how getIOTransfer
treats
the analysis points, with an emphasis on the different uses of u
.
u Specifies...  How getIOTransfer Treats the Analysis Points  Transfer Function  

Loop break Example code: T0 = getIOTransfer(sllin,'e','y','u') 
The software
stops the signal flow at  $$\begin{array}{l}y=G0\hfill \\ \to y=\underset{{T}_{0}}{\underbrace{0}}\hfill \end{array}$$  
Input Example code: T1 = getIOTransfer(sllin,'u','y') 
The software
adds a linearization input,  $$\begin{array}{l}y=G(duKy)\\ \to y=GduGKy\\ \to (I+GK)y=Gdu\\ \to y=\underset{{T}_{1}}{\underbrace{{(I+GK)}^{1}G}}du\end{array}$$  
Openloop input Example code: T2 = getIOTransfer(sllin,'u','y','u') 
The software
breaks the signal flow and adds a linearization input,  $$\begin{array}{l}y=G(du+0)\hfill \\ \to y=\underset{{T}_{2}}{\underbrace{G}}du\hfill \end{array}$$  
Output Example code: T3 = getIOTransfer(sllin,'y','u') 
The software
adds a linearization input,  $$\begin{array}{l}u=K(dy+Gu)\\ \to u=KdyKGu\\ \to (I+KG)u=Kdy\\ \to u=\underset{{T}_{3}}{\underbrace{{(I+KG)}^{1}K}}dy\end{array}$$  
Openloop output Example code: T4 = getIOTransfer(sllin,'y','u','u') 
The software
adds a linearization input,  $$\begin{array}{l}u=K(dy+G0)\hfill \\ \to u=\underset{{T}_{4}}{\underbrace{K}}dy\hfill \end{array}$$  
Complementary sensitivity point Example code: T5 = getIOTransfer(sllin,'u','u')

The software
adds a linearization output and a linearization input,  $$\begin{array}{l}u=KG(du+u)\hfill \\ \to u=KGduKGu\hfill \\ \to (I+KG)u=KGdu\hfill \\ \to u=\underset{{T}_{5}}{\underbrace{{(I+KG)}^{1}KG}}du\hfill \end{array}$$  
Loop transfer function point Example code: T6 = getIOTransfer(sllin,'u','u','u')

The software
adds a linearization output, breaks the loop, and adds a linearization
input,  $$\begin{array}{l}u=KG(du+0)\\ \to u=\underset{{T}_{6}}{\underbrace{KG}}du\end{array}$$ 
The software does not modify the Simulink model when it computes the transfer 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 open 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
(requires
a Robust Control Toolbox™ license).
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 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 use getPoints
to
programmatically obtain a list of all the analysis points.
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
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 use getOpenings
to
programmatically obtain a list of all the permanent openings.
addOpening
 addPoint
 getCompSensitivity
 getLoopTransfer
 getSensitivity
 slLinearizer
 slTuner