Documentation

linearize

Linear approximation of Simulink model or subsystem

Syntax

  • linsys = linearize(sys,io)
    example
  • linsys = linearize(sys,io,op)
    example
  • linsys = linearize(sys,io,tsnapshot)
    example
  • linsys = linearize(sys,blockpath)
    example
  • linsys = linearize(sys,blockpath,op)
    example
  • linsys = linearize(sys,blockpath,tsnapshot)
  • linsys = linearize(sys,blocksub,io)
    example
  • linsys = linearize(sys,blocksub,io,op)
  • linsys = linearize(sys,blocksub,io,tsnapshot)
  • linsys = linearize(___,param)
    example
  • linsys = linearize(___,'StateOrder',stateorder)
    example
  • linsys = linearize(___,options)
    example
  • [linsys,linop] = linearize(___)
    example
  • [linsys,linop,info] = linearize(___)
    example

Description

example

linsys = linearize(sys,io) returns a linear approximation of the nonlinear Simulink® model, sys, at the model operating point using linearization input/output set io. If you omit io, then linearize uses the root level inports and outports of the model as linearization I/Os.

example

linsys = linearize(sys,io,op) linearizes the model at operating point, op. To compute operating points from specifications or at simulation snapshot times, use findop.

example

linsys = linearize(sys,io,tsnapshot) simulates the system and linearizes the model at the specified snapshot times, tsnapshot.

example

linsys = linearize(sys,blockpath) linearizes the block or subsystem in sys specified by blockpath at the model operating point. The software isolates the block from the rest of the model before linearization.

example

linsys = linearize(sys,blockpath,op) linearizes the specified block at operating point op.

linsys = linearize(sys,blockpath,tsnapshot) simulates the system and linearizes the specified block at the specified snapshot times, tsnapshot.

example

linsys = linearize(sys,blocksub,io) linearizes sys using the substitute block or subsystem linearizations specified in blocksub. The linearization uses the model operating point and linearization I/O set io.

linsys = linearize(sys,blocksub,io,op) linearizes sys at operating point op using the specified block linearizations.

linsys = linearize(sys,blocksub,io,tsnapshot) simulates the system and linearizes the model at the specified snapshot times, tsnapshot, using the specified block linearizations.

example

linsys = linearize(___,param) linearizes the model using the parameter value variations specified in param. You can vary any model parameter with a value given by a variable in the model workspace, the MATLAB® workspace, or a data dictionary.

example

linsys = linearize(___,'StateOrder',stateorder) specifies the order of the states in the linearized model.

example

linsys = linearize(___,options) linearizes the model using additional linearization options.

example

[linsys,linop] = linearize(___) returns the operating point at which the model was linearized. Obtain linearization operating points when linearizing at simulation snapshots, or when varying parameters during linearization.

example

[linsys,linop,info] = linearize(___) returns additional linearization information. To select the linearization information to return in info, specify the corresponding option in options.

Examples

collapse all

Open the Simulink model.

sys = 'watertank';
open_system(sys)

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(sys,io);

linsys is the linear approximation of the plant at the model operating point.

Open the Simulink model.

sys = 'magball';
open_system(sys)

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(sys);
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(sys,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(sys,io,op);

Open the Simulink model.

sys = 'watertank';
open_system(sys)

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(sys,blockpath);

Open Simulink model.

sys = 'magball';
open_system(sys)

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(sys);
opspec.States(5).Known = 1;
opspec.States(5).x = 0.05;
options = findopOptions('DisplayReport','off');
op = findop(sys,opspec,options);

Specify the block path for the block you want to linearize.

blockpath = 'magball/Magnetic Ball Plant';

Linearize the specified block and the specified operating point.

linsys = linearize(sys,blockpath,op);

Open the Simulink model.

sys = 'scdpwm';
open_system(sys)

Extract linearization input and output from the model.

io = getlinio(sys);

Linearize the model at the model operating point.

linsys = linearize(sys,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(sys,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.

sys = 'watertank';
open_system(sys)

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(sys,io,10);

Open the Simulink model.

sys = 'scdcascade';
open_system(sys)

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(sys,io,params);

Open the Simulink model.

sys = 'magball';
open_system(sys)

Linearize the plant at the model operating point.

blockpath = 'magball/Magnetic Ball Plant';
linsys = linearize(sys,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(sys,blockpath,'StateOrder',stateorder);

View the new state order.

linsys.StateName
ans =

  3×1 cell array

    'height'
    'dhdt'
    'Current'

Open the Simulink model.

sys = 'watertank';
open_system(sys)

Specify the block path of the plant.

blockpath = 'watertank/Water-Tank System';

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(sys,blockpath,options)
linsys =
 
  A = 
          H
   H  0.995
 
  B = 
      Water-Tank S
   H       0.02494
 
  C = 
                 H
   Water-Tank S  1
 
  D = 
                 Water-Tank S
   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.

sys = 'watertank';
open_system(sys)

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(sys,io,[0,10]);

Open the Simulink model.

sys = 'watertank';
open_system(sys)

Vary parameters A and b within 10% of their nominal values.

[A_grid,b_grid] = ndgrid(linspace(0.9*A,1.1*A,3),...
                         linspace(0.9*b,1.1*b,4));

Create a parameter structure array, specifying the name and grid points for each parameter.

params(1).Name = 'A';
params(1).Value = A_grid;
params(2).Name = 'b';
params(2).Value = b_grid;

Create a default operating point specification for the model.

opspec = operspec(sys);

Trim the model using the specified operating point specification, parameter grid. Suppress the display of the operating point search report.

opt = findopOptions('DisplayReport','off');
[op,opreport] = findop(sys,opspec,params,opt);

op is a 3-by-4 array of operating point objects that correspond to the specified parameter grid points.

Specify the block path for the plant model.

blockpath = 'watertank/Desired  Water Level';

To store offsets during linearization, create a linearization option set and set StoreOffsets to true.

options = linearizeOptions('StoreOffsets',true);

Batch linearize the plant at the trimmed operating points, using the specified I/O points and parameter variations.

[linsys,linop,info] = linearize(sys,blockpath,op,params,options);

You can use the offsets in info.Offsets when configuring an LPV System block.

info.Offsets
ans = 

  3×4 struct array with fields:

    x
    dx
    u
    y
    StateName
    InputName
    OutputName
    Ts

Input Arguments

collapse all

Simulink model name, specified as a character vector.

Linearization I/O set that contains inputs, outputs, and openings, specified as a linearization I/O object or a vector of linearization I/O objects. To create io:

  • Define the inputs, outputs, and openings using linio.

  • If the inputs, outputs, and openings are specified in the Simulink model, extract these points from the model using getlinio.

Each linearization I/O object in io must correspond to the Simulink model sys or some normal mode model reference in the model hierarchy.

If you omit io, then linearize uses the root level inports and outports of the model as linearization I/Os.

For more information on specifying linearization inputs, outputs, and openings, see Specifying Portion of Model to Linearize.

Operating point for linearization, specified as one of the following:

If you specify parameter variations using param, and the parameters:

  • Affect the model operating point, then specify op as an array of operating points with the same dimensions as the parameter value grid. To obtain the operating points that correspond to the parameter value combinations, batch trim your model using param before linearization. For more information, see Batch Linearize Model at Multiple Operating Points Derived from Parameter Variations.

  • Do not affect the model operating point, then specify op as a single operating point.

Block or subsystem to linearize, specified as a character vector that contains its full block path.

The software treats the inports and outports of the specified block as open-loop inputs and outputs, which isolates it from the rest of the model before linearization.

Substitute linearizations for blocks and subsystems, specified as a structure or an n-by-1 structure array, where n is the number of blocks for which you want to specify a linearization. Use blocksub to specify a custom linearization for a block or subsystem. For example, you can specify linearizations for blocks that do not have analytic linearizations, such as blocks with discontinuities or triggered subsystems.

To study the effects of varying the linearization of a block on the model dynamics, you can batch linearize your model by specifying multiple substitute linearizations for a block.

Each substitute linearization structure has the following fields:

Block path of the block for which you want to specify the linearization, specified as a character vector.

Substitute linearization for the block, specified as one of the following:

  • Double — Specify the linearization of a SISO block as a gain.

  • Array of doubles — Specify the linearization of a MIMO block as an nu-by-ny array of gain values, where nu is the number of inputs and ny is the number of outputs.

  • LTI model, uncertain state-space model, or uncertain real object — The I/O configuration of the specified model must match the configuration of the block specified by Name. Using an uncertain model requires Robust Control Toolbox™ software.

  • Array of LTI models, uncertain state-space models, or uncertain real objects — Batch linearize the model using multiple block substitutions. The I/O configuration of each model in the array must match the configuration of the block for which you are specifying a custom linearization. If you:

    • Vary model parameters using param and specify Value as a model array, the dimensions of Value must match the parameter grid size.

    • Specify op as an array of operating points and Value as a model array, the dimensions of Value must match the size of op.

    • Define block substitutions for multiple blocks, and specify Value as an array of LTI models for one or more of these blocks, the dimensions of the arrays must match.

  • Structure with the following fields:

    FieldDescription
    Specification

    Block linearization, specified as a character vector that contains one of the following

    The specified expression or function must return one of the following:

    • Linear model in the form of a D-matrix

    • Control System Toolbox™ LTI model object

    • Uncertain state-space model or uncertain real object (requires Robust Control Toolbox software)

    The I/O configuration of the returned model must match the configuration of the block specified by Name.

    Type

    Specification type, specified as one of the following:

    • 'Expression'

    • 'Function'

    ParameterNames

    Linearization function parameter names, specified as a cell array of character vectors. Specify ParameterNames only when Type = 'Function' and your block linearization function requires input parameters. These parameters only impact the linearization of the specified block.

    You must also specify the corresponding blocksub.Value.ParameterValues field.

    ParameterValues

    Linearization function parameter values, specified as a vector of doubles. The order of parameter values must correspond to the order of parameter names in blocksub.Value.ParameterNames. Specify ParameterValues only when Type = 'Function' and your block linearization function requires input parameters.

Parameter samples for linearization, specified as one of the following:

  • Structure — Vary the value of a single parameter by specifying param as a structure with the following fields:

    • Name — Parameter name, specified as a character vector. You can specify any model parameter that is a variable in the model workspace, the MATLAB workspace, or a data dictionary. If the variable used by the model is not a scalar variable, specify the parameter name as an expression that resolves to a numeric scalar value. For example, to use the first element of vector V as a parameter, use:

      param.Name = 'V(1)';
    • Value — Parameter sample values, specified as a double array.

    For example, vary the value of parameter A in the 10% range:

    param.Name = 'A';
    param.Value = linspace(0.9*A,1.1*A,3);
  • Structure array — Vary the value of multiple parameters. For example, vary the values of parameters A and b in the 10% range:

    [A_grid,b_grid] = ndgrid(linspace(0.9*A,1.1*A,3),...
                             linspace(0.9*b,1.1*b,3));
    params(1).Name = 'A';
    params(1).Value = A_grid;
    params(2).Name = 'b';
    params(2).Value = b_grid;

For more information, see Specify Parameter Samples for Batch Linearization.

If param specifies tunable parameters only, the software batch linearizes the model using a single model compilation.

To compute the offsets required by the LPV System block, specify param, and set options.StoreOffsets to true. You can then return additional linearization information in info, and extract the offsets using getOffsetsForLPV.

Simulation snapshot times at which to linearize the model, specified as a scalar for a single snapshot, or a vector for multiple snapshots. The software simulates sys and linearizes the model at the specified snapshot times.

If you also specify parameter variations using param, the software simulates the model for each snapshot time and parameter grid point combination. This operation can be computationally expensive.

State order in linearization results, specified as a cell array of block paths or state names. The order of the block paths and states in stateorder indicates the order of the states in linsys.

You can specify block paths for any blocks in sys that have states, or any named states in sys.

You do not have to specify every block and state from sys in stateorder. The states you specify appear first in linsys, followed by the remaining states in their default order.

Linearization algorithm options, specified as a linearizeOptions option set.

Output Arguments

collapse all

Linearization result, returned as a state-space model or an array of state-space models. The dimensions of linsys depend on the specified parameter variations and block substitutions, and the operating points or snapshots at which you linearize the model.

    Note:   If you specify more than one of op, param, orblocksub.Value as an array, then their dimensions must match.

Parameter VariationBlock SubstitutionLinearize at...Resulting linsys Dimensions
No parameter variationNo block substitutionModel operating pointSingle state-space model
Single operating point, specified by op
Single snapshot, specified by tsnapshot
N1-by-...-by-Nm array of operating points, specified by opN1-by-...-by-Nm
Ns snapshots, specified by tsnapshotColumn vector of length Ns
N1-by-...-by-Nm model array for at least one block, specified by blocksub.ValueModel operating pointN1-by-...-by-Nm
Single operating point, specified by op
Single snapshot, specified by tsnapshot
N1-by-...-by-Nm array of operating points, specified by op
Ns snapshots, specified by tsnapshotNs-by-N1-by-...-by-Nm
N1-by-...-by-Nm parameter grid, specified by paramEither no block substitution or an N1-by-...-by-Nm model array for at least one block, specified by blocksub.ValueModel operating pointN1-by-...-by-Nm
Single operating point, specified by op
Single snapshot, specified by tsnapshot
N1-by-...-by-Nm array of operating points, specified by op
Ns snapshots, specified by tsnapshotNs-by-N1-by-...-by-Nm

For example, suppose:

  • op is a 4-by-3 array of operating point objects and you do not specify parameter variations or block substitutions. In this case, linsys is a 4-by-3 model array.

  • op is a single operating point object and param specifies a 3-by-4-by-2 parameter grid. In this case, linsys is a 3-by-4-by-2 model array.

  • tsnapshot is a row vector with two elements and you do not specify param. In this case, linsys is a column vector with two elements.

  • tsnapshot is a column vector with three elements and param specifies a 5-by-6 parameter grid. In this case, linsys is a 3-by-5-by-6 model array.

  • op is a single operating point object, you do not specify parameter variations, and blocksub.Value is a 2-by-3 model array for one block in the model. In this case, linsys is a 2-by-3 model array.

  • tsnapshot is a column vector with four elements, you do not specify parameter variations, and blocksub.Value is a 1-by-2 model array for one block in the model. In this case, linsys is a 4-by-1-by-2 model array.

For more information on model arrays, see Model Arrays.

Operating point at which the model was linearized, returned as an operating point object or an array of operating point objects with the same dimensions as linsys. Each element of linop is the operating point at which the corresponding linsys model was obtained.

If you specify an operating point or operating point array using op, then linop is a copy of op. If you specify op as a single operating point and also specify parameter variations using param, then linop is an array with the same dimensions as the parameter grid. In this case, the elements of linop are scalar expanded copies of op.

To determine whether the model was linearized at a reasonable operating point, view the states and inputs in linop.

Linearization information, returned as a structure with the following field:

Linearization offsets that correspond to the operating point at which the model was linearized, returned as [] if options.StoreOffsets is false. Otherwise, Offsets is returned as one of the following:

  • If linsys is a single state-space model, then Offsets is a structure.

  • If linsys is an array of state-space models, then Offsets is a structure array with the same dimensions as linsys.

Each offset structure has the following fields:

FieldDescription
xState offsets used for linearization, returned as a column vector of length nx, where nx is the number of states in linsys.
yOutput offsets used for linearization, returned as a column vector of length ny, where ny is the number of outputs in linsys.
uInput offsets used for linearization, returned as a column vector of length nu, where nu is the number of inputs in linsys.
dxDerivative offsets for continuous time systems, or updated state values for discrete-time systems, returned as a column vector of length nx.
StateNameState names, returned as a cell array that contains nx elements that match the names in linsys.StateName.
InputNameInput names, returned as a cell array that contains nu elements that match the names in linsys.InputName.
OutputNameOutput names, returned as a cell array that contains ny elements that match the names in linsys.OutputName.
TsSample time of the linearized system, returned as a scalar that matches the sample time in sys.Ts. For continuous-time systems, Ts is 0.

If Offsets is a structure array, you can configure an LPV System block using the offsets. To do so, first convert them to the required format using getOffsetsForLPV. For an example, see Approximating Nonlinear Behavior using an Array of LTI Systems.

Alternatives

As an alternative to the linearize function, you can linearize models using one of the following methods:

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.

More About

collapse all

Custom Linearization Function

You can specify a substitute linearization for a block or subsystem in your Simulink model using a custom function on the MATLAB path.

Your custom linearization function, must have one input argument, BlockData, which is a structure that the software creates and passes to the function. BlockData has the following fields:

FieldDescription
BlockNameName of the block for which you are specifying a custom linearization.
ParametersBlock parameter values, specified as a structure array with Name and Value fields. Parameters contains the names and values of the parameters you specify in the blocksub.Value.ParameterNames and blocksub.Value.ParameterValues fields.
InputsInput signals to the block for which you are defining a linearization, specified as a structure array with one structure for each block input. Each structure in Inputs has the following fields:
FieldDescription
BlockNameFull block path of the block whose output connects to the corresponding block input.
PortIndexOutput port of the block specified by BlockName that connects to the corresponding block input.
ValuesValue of the signal specified by BlockName and PortIndex. If this signal is a vector signal, then Values is a vector with the same dimension.

nyNumber of output channels of the block linearization.
nuNumber of input channels of the block linearization.
BlockLinearizationCurrent default linearization of the block, specified as a state-space model. You can specify a block linearization that depends on the default linearization using BlockLinearization.

Your custom function must return a model with nu inputs and ny outputs. This model must be one of the following:

  • Linear model in the form of a D-matrix

  • Control System Toolbox LTI model object

  • Uncertain state-space model or uncertain real object (requires Robust Control Toolbox software)

For example, the following function multiplies the current default block linearization by a delay of Td = 0.5 seconds. The delay is represented by a Thiran filter with sample time Ts = 0.1. The delay and sample time are parameters stored in BlockData.

function sys = myCustomFunction(BlockData)
    Td = BlockData.Parameters(1).Value;
    Ts = BlockData.Parameters(2).Value;
    sys = currentSys*Thiran(Td,Ts);
end 

Save this function to a location on the MATLAB path.

To use this function as a custom linearization for a block or subsystem, specify the blocksub.Value.Specification and blocksub.Value.Type fields.

blocksub.Value.Specification = 'myCustomFunction';
blocksub.Value.Specification = 'Function';

To set the delay and sample time parameter values, specify the blocksub.Value.ParameterNames and blocksub.Value.ParameterValues fields.

blocksub.Value.ParameterNames = {'Td','Ts'};
blocksub.Value.ParameterValues = [0.5 0.1];

Algorithms

Model Properties for Linearization

By default, linearize automatically sets the following Simulink model properties:

  • BufferReuse = 'off'

  • RTWInlineParameters = 'on'

  • BlockReductionOpt = 'off'

  • SaveFormat = 'StructureWithTime'

After linearization, Simulink restores the original model properties.

Block-by-Block Linearization

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 linearizes the model by perturbing the block inputs and states and measuring the response to these perturbations. For each input and state, the default perturbation level is 105(1+|x|), where x is the value of the corresponding input or state at the operating point. For information on how to change perturbation levels for individual blocks, see Change Perturbation Level of Blocks Perturbed During Linearization.

For more information, see Linearizing Nonlinear Models and Exact Linearization Algorithm

Full-Model Numerical Perturbation

You can also linearize your system using full-model numerical perturbation. To do so, create a linearizeOptions set and set the LinearizationAlgorithm to 'numericalpert'. The software computes the linearization of the full model by perturbing the values of the root-level inports and states of the model. This algorithm ignores linear analysis points set in the model and uses root-level inports and outports instead.

For each inport and state, the software perturbs the model and measures the model response to these perturbations. You can configure the state and input perturbation levels using the NumericalPertRel linearization options.

Block-by-block linearization has several advantages over full-model numerical perturbation:

  • Many Simulink blocks have a preprogrammed linearization that provides an exact linearization of the block.

  • You can use linear analysis points to specify a portion of the model to linearize.

  • You can configure blocks to use custom linearizations without affecting your model simulation.

  • Structurally nonminimal states are automatically removed.

  • You can specify linearizations that include uncertainty (requires Robust Control Toolbox software).

  • You can obtain detailed diagnostic information

  • When linearizing multirate models, you can use different rate conversion methods. Full-model numerical perturbation can only use zero-order-hold rate conversion.

For more information, see Linearizing Nonlinear Models and Exact Linearization Algorithm.

Introduced in R2006a

Was this topic helpful?