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, time-domain or frequency-domain 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 closed-loop* 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 closed-loop transfer function
as the transfer function from `dr` to `y`,
which is equal to (*I*+*G**K*)^{-1}*G**K*.

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 open-loop and closed-loop 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 *open-loop
input*. In `T3`, `u` specifies
only an output, whereas in `T4`, `u` specifies
an output and an opening, also referred to as an *open-loop
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 `u`, adds a linearization
input, `de`, at `e`, and a linearization
output at `y`. | $$\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, `du`, at `u`,
and a linearization output at `y`. | $$\begin{array}{l}y=G(du-Ky)\\ \to y=Gdu-GKy\\ \to (I+GK)y=Gdu\\ \to y=\underset{{T}_{1}}{\underbrace{{(I+GK)}^{-1}G}}du\end{array}$$ |

**Open-loop input**
Example
code: `T2 = getIOTransfer(sllin,'u','y','u')` |
The software
breaks the signal flow and adds a linearization input, `du`,
at `u`, and a linearization output at `y`. | $$\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, `dy`, at `y` and
a linearization output at `u`. | $$\begin{array}{l}u=-K(dy+Gu)\\ \to u=-Kdy-KGu\\ \to (I+KG)u=-Kdy\\ \to u=\underset{{T}_{3}}{\underbrace{-{(I+KG)}^{-1}K}}dy\end{array}$$ |

**Open-loop output**
Example
code: `T4 = getIOTransfer(sllin,'y','u','u')` |
The software
adds a linearization input, `dy`, at `y` and
adds a linearization output and breaks the signal flow at `u`. | $$\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, `du`,
at `u`. | $$\begin{array}{l}u=-KG(du+u)\hfill \\ \to u=-KGdu-KGu\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, `du`, at `u`. | $$\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.