Simulink Linearize

Simulink Linearization

Extract linear time invariant (LTI) or linear parameter varying (LPV) models from Simulink using linearize and related APIs from Simulink Control Design.

When to Use

• Obtaining a linear model (tf, ss, zpk) from a Simulink model
• Batch linearization across operating points and parameter variations
• Building LPV models with ssInterpolant
• Debugging linearization results (zero gain, unexpected dynamics)
• Extracting multiple LTI systems with a single model compile

When NOT to Use

• Frequency response estimation from simulation — use simulink-frequency-response for frestimate-based fallback
• No Simulink model is involved

Workflow

The linearization pipeline has four stages. Not every task requires all stages.

Copy code
1. Define I/O Points 2. Operating Point  →  3. Linearize  →  4. Debug  
    (root level/linio)   (findop/operspec)     (linearize)     (advisor) 

Stage 1: Define Linearization I/O Points

Determine I/O points using this decision sequence. Use the first case that applies:

Case A — IO points can be inferred from prompt or model context:

Use the first sub-case that matches:

1. User specifies explicit I/O signals or blocks (e.g., "from r to y") → define linio points. All linio points must reference a block's output port. If a candidate block has no output ports (Outport, Terminator, Scope) → trace upstream to find the source block and port with model_read.

   matlabCopy code
   io = [linio(sprintf("%s/InputBlock", mdl), 1, "input"); ...
         linio(sprintf("%s/OutputBlock", mdl), 1, "output")];
   

2. User targets a specific block or subsystem (e.g., "linearize the Controller") → Use the block path as the io argument signaling linearize to perform open-loop linearization of the block

   matlabCopy code
   io = sprintf("%s/Controller", mdl);
   

3. Model has existing linearization points → io = getlinio(mdl); — use if non-empty.

4. Root-level Inport/Outport blocks exist → omit linio. The linearize command will linearize about the model's root-level I/Os. Use model_read at root scope (depth "0") to confirm root-level Inport/Outport blocks exist.

Case B — Cannot determine IO points:

If none of the above apply → do not guess. Ask the user which signals to use as linearization inputs and outputs. Present the available blocks/signals from the model to help them decide.

Block path rules:

• Use sprintf for block names containing special characters (newlines, commas):

  matlabCopy code
  blkPath = sprintf("%s/Integrator,\nSecond-Order", mdl);
  io = linio(blkPath, 1, "output");
  
  sub.Name = sprintf("%s/My\nBlock",mdl);
  sub.Value = replacement_lti;
  
  sys = linearize(mdl, io, sub);  
  

Stage 2: Operating Point

Determine where to linearize. Choose one:

For batch workflows, use copy to create the operating point array:

matlabCopy code
% assign varied variable to workspace
myvar = 0;
% create base spec
opBase = operspec(mdl);
opBase.States(1).Known = true;
% define param to vary
nPts = 5;
params.Name = "myvar";
params.Value = linspace(-pi, pi, nPts);
for i = nPts:-1:1
    opArray(i) = copy(opBase);
    opArray(i).States(1).x = params.Value(i);
end
ops = findop(mdl, opArray, params, findopOptions());

Stage 3: Linearize

matlabCopy code
sys = linearize(mdl, OPTIONAL_ARGS);

Each input argument to linearize is optional (beside mdl).

matlabCopy code
sys = linearize(mdl, io, op, params, blocksub, opts);

Multi-rate models default to the LCM sample time. Use the SampleTime option to specify linear model sample time:

matlabCopy code
opts = linearizeOptions(SampleTime=0);
sys = linearize(mdl, io, opts);

Batch linearization for LPV:

matlabCopy code
opts = linearizeOptions(BatchConsistency="on", StoreOffsets="system");
sysArray = linearize(mdl, io, ops, params, opts);
lpvSys = ssInterpolant(sysArray);

When StoreOffsets="system", offsets are embedded in each model of the array. Call ssInterpolant(sysArray) with no offset argument.

Define SamplingGrid if one is not generated from linearize (params argument is omitted).

Multiple transfer functions (single compile) with slLinearizer:

matlabCopy code
sllin = slLinearizer(mdl);
addPoint(sllin, ["r", "y", "e", "u"]);
T = getIOTransfer(sllin, "r", "y");
S = getSensitivity(sllin, "e");
L = getLoopTransfer(sllin, "u", sign);

Stage 4: Debug (Linearization Advisor)

Use when linearization returns zero gain or unexpected results.

matlabCopy code
opts = linearizeOptions(StoreAdvisor=true);
[sys, ~, info] = linearize(mdl, io, opts);
advisorResult = advise(info.Advisor);

Always capture the output of advise — calling without an output argument launches the UI.

Inspect problematic blocks:

matlabCopy code
problematic = find(advisorResult, linqueryHasDiagnostics());
for i = 1:numel(problematic.BlockDiagnostics)
    diag = problematic.BlockDiagnostics(i);
    fprintf('%s: %s\n', diag.BlockPath, join(string(diag.DiagnosticMessages), newline));
end

Common advisor findings and resolutions:

• "linearization has zero input/output pair" → Change operating point, or use block substitution if reasonable to do so
• Block with hard discontinuity (PWM, relay, dead zone, non-floating point signals) → Analytical linearization will be zero. Fall back to frequency response estimation
• Reference diagnostic message for other potential fixes

Convert if needed

matlabCopy code
tfSys = tf(sys);      % Transfer function
zpkSys = zpk(sys);    % Zero-pole-gain

LPV Validation

For LPV models, simulate and compare against Simulink:

matlabCopy code
[y, t] = lsim(lpvSys, u, tVec, x0, paramTrajectory);

Key Functions

Common Mistakes

Conventions

• Always: Capture the output of advise() to prevent UI launch
• Always: Use copy(opSpec) for batch operating point arrays, not assignment
• Always: Set BatchConsistency="on" for batch linearization destined for LPV
• Always: Set StoreOffsets="system" when building LPV models with ssInterpolant
• Prefer: slLinearizer when extracting multiple transfer functions from one model
• Never: Place linio on blocks without output ports (Outport, Terminator, Scope) — trace upstream to find the source block
• Never: Use linmod, linmod2, linmodv5 or dlinmod — these are legacy

Copyright 2026 The MathWorks, Inc.