---

name: simulink-frequency-response description: > Estimate frequency response from Simulink models using frestimate. Use when frequency response should be obtained from simulation rather than model linearization. license: https://www.mathworks.com/content/dam/mathworks/license/pmrl/license.md metadata: author: MathWorks version: "1.0"

Simulink Frequency Response Estimation

Obtain frequency response data from Simulink models using simulation-based estimation (frestimate) when analytical linearization is not viable or as a validation tool.

When to Use

• Model contains hard discontinuities (PWM, switching, relay, quantizer) that linearize to zero or NaN
• Validating a linear model against a simulation based linearization of a Simulink model
• Estimating frequency response directly from simulation data

When NOT to Use

• Model linearizes cleanly with linearize — use simulink-linearize instead
• Working with measured data only (no Simulink model) — use System Identification Toolbox

Workflow

1. Define I/O  →  2. Choose Signal  →  3. Configure  →  4. Estimate  →  5. Fit (optional)
   (linio)          (PRBS/Sinestream)    (constraints)    (frestimate)     (tfest)

Stage 1: Define I/O Points

Determine I/O points for the estimation 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.

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

2. Root-level Inport/Outport blocks exist → use model_read at root scope (depth "0") to identify root-level Inport/Outport blocks, then define linio at those blocks (trace Outport blocks upstream to their source for the output linio point).

Case B — Cannot determine IO points:

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

Pre-flight checks (before choosing a signal):

1. Verify I/O points are NOT at blocks without output ports (Outport, Terminator, Scope)
2. Check sample times at I/O points — both must match the perturbation signal rate, or both must be continuous
3. Consider whether the model has time-varying source blocks (Step, Ramp, Signal Generator, etc.) that could drive the system away from its steady-state operating point during estimation. If so, see Disabling Time-Varying Sources below.

Stage 2: Choose Perturbation Signal

Decision (follow in order):

1. Is broadband estimation sufficient (most cases)? → Use frest.PRBS (DEFAULT)
2. Is the model discrete? → Use frest.PRBS with Ts matching the I/O sample time, or frest.createFixedTsSinestream if per-frequency data needed
3. Do you need precise magnitude/phase at specific frequencies? → Use frest.Sinestream (continuous) or frest.createFixedTsSinestream (discrete)

Prefer frest.PRBS — it estimates the full frequency range in a single simulation. Sinestream simulates each frequency sequentially and is significantly slower for broadband estimation.

Stage 3: Configure the Signal

PRBS (default):

in = frest.PRBS(Ts=Ts, Amplitude=0.01, Order=10, NumPeriods=2);

If the I/O signal is discrete, set Ts to match the signal sample time. If continuous, set Ts to a value that provides sufficient temporal resolution. Choose Amplitude small enough to stay in the linear regime of saturations/nonlinearities.

Why PRBS first? A single PRBS simulation estimates the full frequency range at once. Sinestream simulates each frequency sequentially — for 30 frequencies with 8 periods each, this can take 10-100x longer. Use Sinestream only when you need precise per-frequency data (e.g., gain/phase margin at specific crossover frequencies).

Sinestream (continuous models):

in = frest.Sinestream(Frequency=logspace(-1, 2, 30), Amplitude=0.01);
in.NumPeriods = 8;
in.SettlingPeriods = 3;

The filtering constraint: NumPeriods - SettlingPeriods >= 3 when ApplyFilteringInFRESTIMATE = "on" (default). Violating this throws an error at estimation time.

Fixed-Ts Sinestream (discrete models):

Ts = 0.01;
in = frest.createFixedTsSinestream(Ts, {wmin, wmax});
in.Amplitude = 0.01;
in.NumPeriods = 8;
in.SettlingPeriods = 3;

Use the cell syntax {wmin, wmax} for the frequency range — this auto-selects frequencies that are valid integer divisors of the sampling frequency. Do NOT pass an explicit frequency vector:

% CORRECT — cell syntax auto-selects valid frequencies
in = frest.createFixedTsSinestream(Ts, {wmin, wmax});

% WRONG — explicit vector (most frequencies violate integer-multiple constraint)
in = frest.createFixedTsSinestream(Ts, logspace(-1, 2, 30));  % Error

When to use Sinestream instead of PRBS:

• PRBS results are too noisy (high variance at individual frequencies)
• Need precise magnitude/phase at specific frequencies
• Very nonlinear system where broadband excitation causes intermodulation

Check simulation time: Always verify that the signal duration is practical before launching the estimation:

tFinal = getSimulationTime(in);
fprintf("Estimated simulation time: %.1f seconds\n", tFinal);

If tFinal is too big compared to Ts, use larger lower frequency bounds for estimation.

Stage 4: Estimate

Determine where to start the experiment. Choose one:

Situation	Approach
Model ICs	Skip — frestimate uses model initial conditions
Steady-state trim	operspec → configure → findop
Need snapshot from simulation	findop(mdl, tSnapshot)
Operating point known	operpoint object → configure

sysest = frestimate(mdl, op, io, in, opts);

op and opts are optional arguments. If op is not provided, the experiment will start at model initial conditions.

opts is a frestimateOptions object. Pass it when time-varying sources need to be disabled (see below).

The result is an frd (frequency response data) object.

Stage 5: Fit Parametric Model (Optional)

Only perform this step if a parametric model (transfer function, state-space, zpk) is required. If the goal is frequency response data only (e.g., Bode plot, gain/phase margins from frd), stop after Stage 4.

Convert the non-parametric frd to a parametric model:

sysFit = tfest(sysest, np, nz);
fprintf("Fit: %.1f%%\n", sysFit.Report.Fit.FitPercent);

Disabling Time-Varying Sources

Time-varying source blocks (Step, Ramp, Signal Generator, etc.) can drive the model away from its steady-state operating point during estimation. When this happens, the system does not remain near the operating point and the estimated response is unreliable — gain estimates can be off by orders of magnitude while executing without error.

When to disable sources:

• The model contains source blocks (other than the perturbation input) that change value during the estimation simulation
• Estimation results are implausible or don't match an expected linearization
• The time-domain response does not reach steady state at individual frequencies

How to identify and disable them:

Use frest.findSources to identify time-varying source blocks in the estimation path, then set BlocksToHoldConstant so they are held at their initial value during estimation:

srcblks = frest.findSources(mdl, io);
opts = frestimateOptions;
opts.BlocksToHoldConstant = srcblks;
sysest = frestimate(mdl, io, in, opts);

Note: frest.findSources requires model compilation. The perturbation input is not affected by BlocksToHoldConstant.

The Fallback Pattern

When linearize returns zero, follow this sequence:

% 1. Try linearize
sys = linearize(mdl, io);
if dcgain(sys) == 0
    % 2. Disable time-varying sources if present
    srcblks = frest.findSources(mdl, io);
    opts = frestimateOptions;
    opts.BlocksToHoldConstant = srcblks;
    % 3. Fall back to frestimate with PRBS
    in = frest.PRBS(Ts=Ts, Amplitude=0.01, Order=10, NumPeriods=2);
    sysest = frestimate(mdl, io, in, opts);
    % 4. Fit parametric model
    sysFit = tfest(sysest, 2);
end

Do NOT use manual block substitution (replace_block) as a workaround for zero linearization. The frestimate approach is generalizable to any discontinuous model without requiring domain knowledge of each block's averaged equivalent.

Key Functions

Function	Purpose	Available From
frestimate	Estimate frequency response from Simulink	R2009b
frest.findSources	Identify time-varying source blocks to hold constant	R2010b
frestimateOptions	Options including BlocksToHoldConstant	R2010a
frest.PRBS	Pseudorandom binary sequence signal	R2020a
frest.Sinestream	Multi-sine perturbation signal	R2009b
frest.createFixedTsSinestream	Fixed sample time sinestream	R2009b
getSimulationTime	Check signal duration before running	R2012a
tfest	Fit transfer function to frequency data	R2012a
ssest	Fit state-space model to frequency data	R2012a

Common Mistakes

Mistake	Why It Fails	Correct Approach
Not disabling time-varying sources	Source blocks drive the model away from its steady-state operating point, producing unreliable estimates without error	Use frest.findSources to identify sources, set opts.BlocksToHoldConstant to disable them
Using replace_block to work around zero linearization	Requires domain knowledge of averaged equivalents; doesn't generalize	Use frestimate with PRBS — works for any discontinuous model
Setting NumPeriods=5, SettlingPeriods=3 with filtering on	Violates NumPeriods - SettlingPeriods >= 3 constraint	Use NumPeriods=8, SettlingPeriods=3 or disable filtering
Output linio at different rate than input signal	frestimate rejects multi-rate I/O configurations	Place both I/O points at blocks matching the signal's sample time
Only using frest.Sinestream (ignoring PRBS)	Sinestream is much slower — simulates each frequency sequentially	Start with frest.PRBS for broadband estimation; use Sinestream only when frequency-by-frequency precision is needed
Large perturbation amplitude near saturations	Drives system into nonlinear regime, corrupting estimation	Choose amplitude small relative to saturation limits (e.g., 1-5% of range)

Conventions

• Always: Consider whether time-varying sources could drive the model from its operating point — use frest.findSources and BlocksToHoldConstant to disable them
• Prefer: frest.PRBS for broadband estimation — faster than Sinestream for most workflows
• Always: Use cell syntax {wmin, wmax} with frest.createFixedTsSinestream
• Always: Ensure NumPeriods - SettlingPeriods >= 3 when filtering is enabled
• Always: Place I/O points at rate-compatible blocks for multi-rate models
• Always: Call getSimulationTime — Validate signal duration before running. Long simulations relative to max solver step size should prompt redesign.
• Prefer: frestimate over manual block substitution for discontinuous models
• Prefer: tfest or ssest for fitting parametric models to frd results
• Prefer: Small amplitude — Keep perturbation small enough to stay in the locally linear regime (typically 1-5% of operating range).
• Never: Use replace_block as a general linearization workaround

---

Copyright 2026 The MathWorks, Inc.

---