Exact Linearization Algorithm

Simulink^® Control Design™ software linearizes models using a block-by-block approach. The software individually linearizes each block in your Simulink model and produces the linearization of the overall system by combining the individual block linearizations.

The software determines the input and state levels for each block from the operating point, and requests the Jacobian for these levels from each block.

For some blocks, the software cannot compute an analytical linearization. For example:

Some nonlinearities do not have a defined Jacobian.
Some discrete blocks, such as state charts and triggered subsystems, tend to linearize to zero.
Some blocks do not implement a Jacobian.
Custom blocks, such as S-Function blocks and MATLAB Function blocks, do not have analytical Jacobians.

You can specify a custom linearization for any such blocks for which you know the expected linearization. If you do not specify a custom linearization, the software finds the linearization by perturbing the block inputs and states and measuring the response to these perturbations. For more information, see Perturbation of Individual Blocks.

Continuous-Time Models

Simulink Control Design software lets you linearize continuous-time nonlinear systems. The resulting linearized model is in state-space form.

In continuous time, the state space equations of a nonlinear system are:

$\begin{array}{l} \dot{x} (t) = f (x (t), u (t), t) \\ y (t) = g (x (t), u (t), t) \end{array}$

where x(t) are the system states, u(t) are the input signals, and y(t) are the output signals.

To describe the linearized model, define a new set of variables of the states, inputs, and outputs centered about the operating point:

$\begin{array}{l} δ x (t) = x (t) - x_{0} \\ δ u (t) = u (t) - u_{0} \\ δ y (t) = y (t) - y_{0} \end{array}$

The output of the system at the operating point is y(t₀)=g(x₀,u₀,t₀)=y₀.

The linearized state-space equations in terms of δx(t), δu(t), and δy(t) are:

$\begin{array}{l} δ \dot{x} (t) = A δ x (t) + B δ u (t) \\ δ y (t) = C δ x (t) + D δ u (t) \end{array}$

where A, B, C, and D are constant coefficient matrices. These matrices are the Jacobians of the system, evaluated at the operating point:

$\begin{array}{l} A = {\frac{\partial f}{\partial x} |}_{t_{0}, x_{0}, u_{0}} B = {\frac{\partial f}{\partial u} |}_{t_{0}, x_{0}, u_{0}} \\ C = {\frac{\partial g}{\partial x} |}_{t_{0}, x_{0}, u_{0}} D = {\frac{\partial g}{\partial u} |}_{t_{0}, x_{0}, u_{0}} \end{array}$

This linear time-invariant approximation to the nonlinear system is valid in a region around the operating point at t=t₀, x(t₀)=x₀, and u(t₀)=u₀. In other words, if the values of the system states, x(t), and inputs, u(t), are close enough to the operating point, the system behaves approximately linearly.

The transfer function of the linearized model is the ratio of the Laplace transform of δy(t) and the Laplace transform of δu(t):

$P_{l i n} (s) = \frac{δ Y (s)}{δ U (s)}$

Multirate Models

Simulink Control Design software lets you linearize multirate nonlinear systems. The resulting linearized model is in state-space form.

Multirate models include states with different sampling rates. In multirate models, the state variables change values at different times and with different frequencies. Some of the variables might change continuously.

The general state-space equations of a nonlinear, multirate system are:

$\begin{matrix} \dot{x} (t) & = & f (x (t), x_{1} (k_{1}), \dots, x_{m} (k_{m}), u (t), t) \\ x_{1} (k_{1} + 1) & = & f_{1} (x (t), x_{1} (k_{1}), \dots, x_{m} (k_{m}), u (t), t) \\ ⋮ & ⋮ \\ x_{m} (k_{m} + 1) & = & f_{i} (x (t), x_{1} (k_{1}), \dots, x_{m} (k_{m}), u (t), t) \\ y (t) & = & g (x (t), x_{1} (k_{1}), \dots, x_{m} (k_{m}), u (t), t) \end{matrix}$

where k₁,..., k_m are integer values and $t_{k_{1}}$ ,..., $t_{k_{m}}$ are discrete times.

The linearized equations that approximate this nonlinear system as a single-rate discrete model are:

$\begin{matrix} δ x_{k + 1} & \approx & A δ x_{k} + B δ u_{k} \\ δ y_{k} & \approx & C δ x_{k} + D δ u_{k} \end{matrix}$

The rate of the linearized model is typically the least common multiple of the sample times, which is usually the slowest sample time.

For more information, see Linearize Multirate Models.

Perturbation of Individual Blocks

Simulink Control Design software linearizes blocks that do not have a preprogrammed linearization using numerical perturbation. The software computes the block linearization by numerically perturbing the states and inputs of the block about the operating point of the block.

The block perturbation algorithm introduces a small perturbation to the nonlinear block and measures the response to this perturbation. The default difference between the perturbed value and the operating point value is $10^{- 5} (1 + | x |)$ , where x is the operating point value. The software uses this perturbation and the resulting response to compute the linear state-space of this block. For information on how to change perturbation levels for individual blocks, see Change Perturbation Level of Blocks Perturbed During Linearization.

In general, a continuous-time nonlinear Simulink block in state-space form is given by:

$\begin{array}{l} \dot{x} (t) = f (x (t), u (t), t) \\ y (t) = g (x (t), u (t), t) . \end{array}$

In these equations, x(t) represents the states of the block, u(t) represents the inputs of the block, and y(t) represents the outputs of the block.

A linearized model of this system is valid in a small region around the operating point t=t₀, x(t₀)=x₀, u(t₀)=u₀, and y(t₀)=g(x₀,u₀,t₀)=y₀.

To describe the linearized block, define a new set of variables of the states, inputs, and outputs centered about the operating point:

$\begin{array}{l} δ x (t) = x (t) - x_{0} \\ δ u (t) = u (t) - u_{0} \\ δ y (t) = y (t) - y_{0} \end{array}$

The linearized state-space equations in terms of these new variables are:

$\begin{array}{l} δ \dot{x} (t) = A δ x (t) + B δ u (t) \\ δ y (t) = C δ x (t) + D δ u (t) \end{array}$

A linear time-invariant approximation to the nonlinear system is valid in a region around the operating point.

The state-space matrices A, B, C, and D of this linearized model represent the Jacobians of the block.

To compute the state-space matrices during linearization, the software performs these operations:

Perturbs the states and inputs, one at a time, and measures the response of the system to this perturbation by computing $δ \dot{x}$ and δy.
Computes the state-space matrices using the perturbation and the response.
$\begin{array}{l} A (:, i) = \frac{{\dot{x} |}_{x_{p, i}} - {\dot{x}}_{o}}{x_{p, i} - x_{o}}, B (:, i) = \frac{{\dot{x} |}_{u_{p, i}} - {\dot{x}}_{o}}{u_{p, i} - u_{o}} \\ C (:, i) = \frac{{y |}_{x_{p, i}} - y_{o}}{x_{p, i} - x_{o}}, D (:, i) = \frac{{y |}_{u_{p, i}} - y_{o}}{u_{p, i} - u_{o}} \end{array}$

where

x_p,i is the state vector whose ith component is perturbed from the operating point value.
x_o is the state vector at the operating point.
u_p,i is the input vector whose ith component is perturbed from the operating point value.
u_o is the input vector at the operating point.
${\dot{x} |}_{x_{p, i}}$ is the value of $\dot{x}$ at x_p,i, u_o.
${\dot{x} |}_{u_{p, i}}$ is the value of $\dot{x}$ at u_p,i, x_o.
${\dot{x}}_{o}$ is the value of $\dot{x}$ at the operating point.
${y |}_{x_{p, i}}$ is the value of $y$ at x_p,i, u_o.
${y |}_{u_{p, i}}$ is the value of $y$ at u_p,i, x_o.
y_o is the value of y at the operating point.

User-Defined Blocks

All user defined blocks such as S-Function and MATLAB Function blocks, are compatible with linearization. These blocks are linearized using numerical perturbation.

User-defined blocks do not linearize when these blocks use non-floating-point precision data types. For more information, see Linearize Blocks with Non-Floating-Point Signals or States.

Lookup Tables

Regular lookup tables are numerically perturbed. Pre-lookup tables have a preprogrammed (exact) block-by-block linearization.