linearize
Linear approximation of Simulink model or subsystem
Syntax
Description
linsys = linearize(model,io)model at the model operating point
using the analysis points specified in io. Using
io, you can specify individual analysis points or you
can specify a block or subsystem to linearize. If you omit
io, then linearize uses the
root-level inports and outports of the model as analysis points.
linsys = linearize(___,'StateOrder',stateorder)
Examples
Open the Simulink model.
mdl = 'watertank';
open_system(mdl)
Specify a linearization input at the output of the PID Controller block, which is the input signal for the Water-Tank System block.
io(1) = linio('watertank/PID Controller',1,'input');
Specify a linearization output point at the output of the Water-Tank System block. Specifying the output point as open-loop removes the effects of the feedback signal on the linearization without changing the model operating point.
io(2) = linio('watertank/Water-Tank System',1,'openoutput');
Linearize the model using the specified I/O set.
linsys = linearize(mdl,io);
linsys is the linear approximation of the plant at the model operating point.
Open the Simulink model.
mdl = 'magball';
open_system(mdl)
Find a steady-state operating point at which the ball height is 0.05. Create a default operating point specification, and set the height state to a known value.
opspec = operspec(mdl); opspec.States(5).Known = 1; opspec.States(5).x = 0.05;
Trim the model to find the operating point.
options = findopOptions('DisplayReport','off'); op = findop(mdl,opspec,options);
Specify linearization input and output signals to compute the closed-loop transfer function.
io(1) = linio('magball/Desired Height',1,'input'); io(2) = linio('magball/Magnetic Ball Plant',1,'output');
Linearize the model at the specified operating point using the specified I/O set.
linsys = linearize(mdl,io,op);
Open the Simulink model.
mdl = 'watertank';
open_system(mdl)
To compute the closed-loop transfer function, first specify the linearization input and output signals.
io(1) = linio('watertank/PID Controller',1,'input'); io(2) = linio('watertank/Water-Tank System',1,'output');
Simulate sys for 10 seconds and linearize the model.
linsys = linearize(mdl,io,10);
Open the Simulink model.
mdl = 'scdcascade';
open_system(mdl)
Specify parameter variations for the outer-loop controller gains, Kp1 and Ki1. Create parameter grids for each gain value.
Kp1_range = linspace(Kp1*0.8,Kp1*1.2,6); Ki1_range = linspace(Ki1*0.8,Ki1*1.2,4); [Kp1_grid,Ki1_grid] = ndgrid(Kp1_range,Ki1_range);
Create a parameter value structure with fields Name and Value.
params(1).Name = 'Kp1'; params(1).Value = Kp1_grid; params(2).Name = 'Ki1'; params(2).Value = Ki1_grid;
params is a 6-by-4 parameter value grid, where each grid point corresponds to a unique combination of Kp1 and Ki1 values.
Define linearization input and output points for computing the closed-loop response of the system.
io(1) = linio('scdcascade/setpoint',1,'input'); io(2) = linio('scdcascade/Sum',1,'output');
Linearize the model at the model operating point using the specified parameter values.
linsys = linearize(mdl,io,params);
Open the Simulink model.
mdl = 'scdpwm';
open_system(mdl)
Extract linearization input and output from the model.
io = getlinio(mdl);
Linearize the model at the model operating point.
linsys = linearize(mdl,io)
linsys =
D =
Step
Plant Model 0
Static gain.
The discontinuities in the Voltage to PWM block cause the model to linearize to zero. To treat this block as a unit gain during linearization, specify a substitute linearization for this block.
blocksub.Name = 'scdpwm/Voltage to PWM';
blocksub.Value = 1;
Linearize the model using the specified block substitution.
linsys = linearize(mdl,blocksub,io)
linsys =
A =
State Space( State Space(
State Space( 0.9999 -0.0001
State Space( 0.0001 1
B =
Step
State Space( 0.0001
State Space( 5e-09
C =
State Space( State Space(
Plant Model 0 1
D =
Step
Plant Model 0
Sample time: 0.0001 seconds
Discrete-time state-space model.
Open the Simulink model.
mdl = 'watertank';
open_system(mdl)
To linearize the Water-Tank System block, specify a linearization input and output.
io(1) = linio('watertank/PID Controller',1,'input'); io(2) = linio('watertank/Water-Tank System',1,'openoutput');
Create a linearization option set, and specify the sample time for the linearized model.
options = linearizeOptions('SampleTime',0.1);
Linearize the plant using the specified options.
linsys = linearize(mdl,io,options)
linsys =
A =
H
H 0.995
B =
PID Controll
H 0.02494
C =
H
Water-Tank S 1
D =
PID Controll
Water-Tank S 0
Sample time: 0.1 seconds
Discrete-time state-space model.
The linearized plant is a discrete-time state-space model with a sample time of 0.1.
Open the Simulink model.
mdl = 'watertank';
open_system(mdl)
Specify the full block path for the block you want to linearize.
blockpath = 'watertank/Water-Tank System';
Linearize the specified block at the model operating point.
linsys = linearize(mdl,blockpath);
Open Simulink model.
mdl = 'magball';
open_system(mdl)
Find a steady-state operating point at which the ball height is 0.05. Create a default operating point specification, and set the height state to a known value.
opspec = operspec(mdl); opspec.States(5).Known = 1; opspec.States(5).x = 0.05;
options = findopOptions('DisplayReport','off'); op = findop(mdl,opspec,options);
Specify the block path for the block you want to linearize.
blockpath = 'magball/Magnetic Ball Plant';
Linearize the specified block at the specified operating point.
linsys = linearize(mdl,blockpath,op);
Open the Simulink model.
mdl = 'magball';
open_system(mdl)
Linearize the plant at the model operating point.
blockpath = 'magball/Magnetic Ball Plant';
linsys = linearize(mdl,blockpath);
View the default state order for the linearized plant.
linsys.StateName
ans =
3×1 cell array
{'height' }
{'Current'}
{'dhdt' }
Linearize the plant and reorder the states in the linearized model. Set the rate of change of the height as the second state.
stateorder = {'magball/Magnetic Ball Plant/height';...
'magball/Magnetic Ball Plant/dhdt';...
'magball/Magnetic Ball Plant/Current'};
linsys = linearize(mdl,blockpath,'StateOrder',stateorder);
View the new state order.
linsys.StateName
ans =
3×1 cell array
{'height' }
{'dhdt' }
{'Current'}
Open the Simulink model.
mdl = 'watertank';
open_system(mdl)
To compute the closed-loop transfer function, first specify the linearization input and output signals.
io(1) = linio('watertank/PID Controller',1,'input'); io(2) = linio('watertank/Water-Tank System',1,'output');
Simulate sys and linearize the model at 0 and 10 seconds. Return the operating points that correspond to these snapshot times; that is, the operating points at which the model was linearized.
[linsys,linop] = linearize(mdl,io,[0,10]);
Open the Simulink model.
mdl = 'watertankNLModel';
open_system(mdl)Specify the initial condition for water height.
h0 = 10;
Specify model linear analysis points.
io(1) = linio('watertankNLModel/Step',1,'input'); io(2) = linio('watertankNLModel/H',1,'output');
Simulate the model and extract operating points at time snapshots.
tlin = [0 30 40 50 60 70 80]; op = findop(mdl,tlin);
To store offsets during linearization, create a linearization option set and set StoreOffsets to "struct". Doing so returns the linearization offsets in the info output argument of linearize.
options = linearizeOptions(StoreOffsets="struct");Batch linearize the plant at the trimmed operating points, using the specified I/O points and parameter variations.
[linsys,~,info] = linearize(mdl,io,op,options); info.Offsets
ans=7×1 struct array with fields:
dx
x
u
y
OutputName
InputName
StateName
Ts
You can use the offsets in info.Offsets when configuring an LPV System block. This requires extracting offsets in the supported format using the using getOffsetsForLPV function. Additionally, when using the ssInterpolant function, you must explicitly specify info.Offsets as an additional input argument.
Alternatively, you can store offsets directly in the Offsets property of the linearized ss model. To do so, set StoreOffsets option to "system". (Since R2025a)
options.StoreOffsets = "system";
linsys2 = linearize(mdl,io,op,options);
linsys2.Offsetsans=7×1 struct array with fields:
dx
x
u
y
Storing offsets directly with the system can simplify LPV modeling workflows and facilitate the comparison of the nonlinear and linearized responses of a Simulink® model. For an example on how you can use this system to build a linear parameter-varying model directly using ssInterpolant, see Create LPV Model from Batch Linearization Results.
Since R2025a
This example shows how to obtain an array of state-space models with uniform state consistency when using batch linearization. Building linear parameter-varying models (LPV) models from a state-space array obtained using batch linearization requires consistent and uniform state dimensions, delay modeling, and offset handling across the linearization grid.
For this example, consider a model of physical pendulum. The initial conditions for the pendulum angle is 45 degrees counterclockwise with zero applied torque. Additionally, the initial condition for the pendulum angular velocity is 0 deg/s. Specify the parameters and load the model.
tau0 = 0;
mgl = 1;
inv_inert = 1;
c = 0.1;
theta0 = pi/4;
dtheta0 = 0;
mdl = "scdPendulumNoWrap";
load_system(mdl);In this example, set the linearization to not treat the Saturation block as gain. The Saturation block in this model limits the total torque input between the values -1 and 1. Therefore, linearization will analytically linearize this block to zero if the signal input value lies outside this range.
set_param(mdl+"/clip","LinearizeAsGain","off");
Specify the input to the Saturation block as linearization input and theta as output.
io(1) = linio(mdl+"/tau0",1,"input"); io(2) = linio(mdl+"/pendulum",1,"output");
Create two operating points for linearization. For the second operating point, specify an input level that lies outside the saturation range.
op1 = operpoint(mdl); op2 = copy(op1); op2.Inputs(1).u = 2; op = [op1,op2];
First, linearize the system with the BatchConsistency option set to false.
lin_opt = linearizeOptions(StoreOffsets="system",BlockReduction="on",BatchConsistency=false); sys = linearize(mdl,io,op,lin_opt); sys
sys(:,:,1,1) =
A =
theta theta_dot
theta 0 1
theta_dot -0.7071 -0.1
B =
tau0
theta 0
theta_dot 1
C =
theta theta_dot
pendulum/the 1 0
D =
tau0
pendulum/the 0
sys(:,:,2,1) =
D =
tau0
pendulum/the 0
2x1 array of continuous-time state-space models.
Model Properties
The batch linearization result returns a 2-by-1 array of state-space models corresponding to the defined operating points. The first model in the array has two states but the second model linearizes to zero because the input level lies outside the saturation range. When BatchConsistency is disabled, linearization reduces each model in the array to the maximum extent.
Now, enable the BatchConsistency option and linearize the model again at the same operating conditions.
lin_optc = linearizeOptions(StoreOffsets="system",BlockReduction="on",BatchConsistency=true); sysc = linearize(mdl,io,op,lin_optc); sysc
sysc(:,:,1,1) =
A =
theta theta_dot
theta 0 1
theta_dot -0.7071 -0.1
B =
tau0
theta 0
theta_dot 1
C =
theta theta_dot
pendulum/the 1 0
D =
tau0
pendulum/the 0
sysc(:,:,2,1) =
A =
theta theta_dot
theta 0 1
theta_dot -0.7071 -0.1
B =
tau0
theta 0
theta_dot 0
C =
theta theta_dot
pendulum/the 1 0
D =
tau0
pendulum/the 0
2x1 array of continuous-time state-space models.
Model Properties
The batch linearization now produces an array where both models have two states. When you enable BatchConsistency, linearization removes only the states and delays that do not contribute to the input-output map for all models in the batch linearization array, and hence preserves consistency across all models. This is particularly helpful when building gridded LPV models.
For an example that show how to build an LPV model for this pendulum, see Create LPV Pendulum Model Using Batch Linearization.
Since R2025a
This example shows how to model extra delays that arise during discretization. Typically, discretizing models with input or output delays that are not integer multiples of the model sample time can give rise to additional delays besides the discrete input and output delays. linearize allows you to specify whether you want to model these delays as internal delays or additional states.
Consider a simple Simulink® model, containing an LTI system with two states and an input delay of 2.7 seconds.
sys = tf([1,2],[1,4,2],InputDelay=2.7);
mdl = "linDelayModeling";
load_system(mdl)Linearize the model with a sample time of 1 second. Additionally, set the discretization method to Tustin and specify a third Thiran filter to model the fractional delay.
opt = linearizeOptions(... SampleTime=1,... UseExactDelayModel=true); opt.RateConversionOptions.Method = "tustin"; opt.RateConversionOptions.ThiranOrder = 3; linsys = linearize(mdl,opt)
linsys =
A =
? ? ? ? ?
? -0.4286 -0.5714 -0.00265 0.06954 2.286
? 0.2857 0.7143 -0.001325 0.03477 1.143
? 0 0 -0.2432 0.1449 -0.1153
? 0 0 0.25 0 0
? 0 0 0 0.125 0
B =
in
? 0.002058
? 0.001029
? 8
? 0
? 0
C =
? ? ? ? ?
out 0.2857 0.7143 -0.001325 0.03477 1.143
D =
in
out 0.001029
Sample time: 1 seconds
Discrete-time state-space model.
Model Properties
Linearization returns the discretized model containing three additional states corresponding to a third-order Thiran filter. Since the time delay divided by the sample time is 2.7, the third-order Thiran filter can approximate the entire time delay. In the linearization options opt, the opt.RateConversionOptions.DelayModeling property determines how to model extra delays. By default, it is set to "state" and models extra delays as extra states. To model extra delays as internal model delays instead, you can set DelayModeling to "delay".
opt.RateConversionOptions.DelayModeling = "delay";Linearize the model again.
linsys2 = linearize(mdl,opt)
linsys2 =
A =
? ?
? -0.4286 -0.5714
? 0.2857 0.7143
B =
in
? 0.5714
? 0.2857
C =
? ?
out 0.2857 0.7143
D =
in
out 0.2857
(values computed with all internal delays set to zero)
Internal delays (sampling periods): 1 1 1
Sample time: 1 seconds
Discrete-time state-space model.
Model Properties
The linearization now models extra delays as internal delays in the discretized model.
Input Arguments
Output Arguments
Limitations
Linearization is not supported for model hierarchies that contain referenced models configured to use a local solver.
Linearization is not supported for Simscape™ networks configured to use a local solver.
More About
Algorithms
Alternatives
As an alternative to the linearize function, you can linearize models
using one of the following methods.
To interactively linearize models, use the Model Linearizer app. For an example, see Linearize Simulink Model at Model Operating Point.
To obtain multiple transfer functions without modifying the model or creating an analysis point set for each transfer function, use an
slLinearizerinterface. For an example, see Vary Parameter Values and Obtain Multiple Transfer Functions.
Although both Simulink
Control Design software and the Simulink
linmod function perform block-by-block
linearization, Simulink
Control Design linearization functionality has a more flexible user interface and uses
Control System Toolbox numerical algorithms. For more information, see Linearization Using Simulink Control Design Versus Simulink.
