Main Content

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.

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\left(x(t),u(t),t\right)\\ y(t)=g\left(x(t),u(t),t\right)\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}\delta x(t)=x(t)-{x}_{0}\\ \delta u(t)=u(t)-{u}_{0}\\ \delta y(t)=y(t)-{y}_{0}\end{array}$$

The output of the system at the operating point is
*y*(*t*_{0})=*g*(*x*_{0},*u*_{0},*t*_{0})=*y*_{0}.

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

$$\begin{array}{l}\delta \dot{x}(t)=A\delta x(t)+B\delta u(t)\\ \delta y(t)=C\delta x(t)+D\delta 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}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}B={\frac{\partial f}{\partial u}|}_{{t}_{0},{x}_{0},{u}_{0}}\\ C={\frac{\partial g}{\partial x}|}_{{t}_{0},{x}_{0},{u}_{0}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}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*_{0},
*x*(*t*_{0})=*x*_{0},
and
*u*(*t*_{0})=*u*_{0}.
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}_{lin}(s)=\frac{\delta Y(s)}{\delta U(s)}$$

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{array}{ccc}\dot{x}\left(t\right)& =& f\left(x\left(t\right),{x}_{1}\left({k}_{1}\right),\dots ,{x}_{m}\left({k}_{m}\right),u\left(t\right),t\right)\\ {x}_{1}({k}_{1}+1)& =& {f}_{1}\left(x\left(t\right),{x}_{1}\left({k}_{1}\right),\dots ,{x}_{m}\left({k}_{m}\right),u\left(t\right),t\right)\\ \vdots & & \vdots \\ {x}_{m}({k}_{m}+1)& =& {f}_{i}\left(x\left(t\right),{x}_{1}\left({k}_{1}\right),\dots ,{x}_{m}\left({k}_{m}\right),u\left(t\right),t\right)\\ y\left(t\right)& =& g\left(x\left(t\right),{x}_{1}\left({k}_{1}\right),\dots ,{x}_{m}\left({k}_{m}\right),u\left(t\right),t\right)\end{array}$$

where *k*_{1},...,
*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{array}{ccc}\delta {x}_{k+1}& \approx & A\text{\hspace{0.05em}}\delta {x}_{k}+\text{\hspace{0.05em}}B\text{\hspace{0.05em}}\delta {u}_{k}\\ \delta {y}_{k}& \approx & C\text{\hspace{0.05em}}\delta {x}_{k}+D\text{\hspace{0.05em}}\delta {u}_{k}\end{array}$$

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 Linearization of Multirate Models.

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}\left(1+\left|x\right|\right)$$, 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\left(x(t),u(t),t\right)\\ y(t)=g\left(x(t),u(t),t\right).\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*_{0},
*x*(*t*_{0})=*x*_{0},
*u*(*t*_{0})=*u*_{0},
and
*y*(*t*_{0})=*g*(*x*_{0},*u*_{0},*t*_{0})=*y*_{0}.

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}\delta x(t)=x(t)-{x}_{0}\\ \delta u(t)=u(t)-{u}_{0}\\ \delta y(t)=y(t)-{y}_{0}\end{array}$$

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

$$\begin{array}{l}\delta \dot{x}(t)=A\delta x(t)+B\delta u(t)\\ \delta y(t)=C\delta x(t)+D\delta 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 $$\delta \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}},\text{\hspace{1em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}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}},\text{\hspace{1em}}\text{\hspace{0.17em}}\text{\hspace{0.17em}}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*i*th 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*i*th 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.

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.

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