---
name: Simulating Simulink Models
slug: simulating-simulink-models
category: Automation
description: Simulating Simulink Models configures simulations non-destructively with SimulationInput objects for parameter overrides, custom inputs, batch sweeps, and logged output access. Use it when running sim() or parsim() with setVariable, setBlockParameter, setExternalInput, or when analyzing logsout.
github: "https://github.com/matlab/simulink-agentic-toolkit/tree/main/skills-catalog/model-based-design-core/simulating-simulink-models"
language: HTML
stars: 963
forks: 94
install: "npx degit https://github.com/matlab/simulink-agentic-toolkit/tree/main/skills-catalog/model-based-design-core/simulating-simulink-models ~/.claude/skills/simulating-simulink-models"
installs_to: ~/.claude/skills/simulating-simulink-models
source_path: skills-catalog/model-based-design-core/simulating-simulink-models/SKILL.md
collection_size: 24
category_size: 1523
collection_url: "https://dirskills.com/collections/matlab/simulink-agentic-toolkit"
added: 2026-08-21T05:15:16.638Z
last_synced: 2026-08-21T05:15:16.638Z
canonical_url: "https://dirskills.com/skills/simulating-simulink-models"
---

# Simulating Simulink Models

Simulating Simulink Models configures simulations non-destructively with SimulationInput objects for parameter overrides, custom inputs, batch sweeps, and logged output access. Use it when running sim() or parsim() with setVariable, setBlockParameter, setExternalInput, or when analyzing logsout.

**Install:**

```bash
npx degit https://github.com/matlab/simulink-agentic-toolkit/tree/main/skills-catalog/model-based-design-core/simulating-simulink-models ~/.claude/skills/simulating-simulink-models
```

## README

# Simulating Simulink Models with the sim Command

Use this skill when you need to **configure** a simulation non-destructively — parameter overrides, custom inputs, batch execution, or structured output access. For persistent, reusable pass/fail behavioral testing (especially of individual subsystems), use `testing-simulink-models` instead. For trivial one-shot simulations without configuration, a direct `sim()` call suffices without this skill.

## When to Use

- Overriding model or block parameters non-destructively (setVariable, setBlockParameter, setModelParameter) — without modifying the .slx file
- Passing custom input signals to root-level Inport blocks via setExternalInput with a Dataset
- Running parameter sweeps or batch simulations (SimulationInput arrays, parsim, Fast Restart)
- Accessing logged signal data (logsout) for analysis after simulation

## When NOT to Use

- Trivial one-shot simulations without parameter overrides or custom inputs — a direct `sim('ModelName')` call works without this skill
- Writing declarative Gherkin-based tests → use `testing-simulink-models`
- Testing an individual subsystem or component → use `testing-simulink-models` (requires Simulink Test; auto-creates a harness, compiles only the subsystem — much faster than `sim()` which always compiles the entire model)
- Adding, connecting, or deleting blocks → use `building-simulink-models`
- Checking model structure for unconnected ports → use `model_check` tool directly
- Generating requirements from model behavior → use `generate-requirement-drafts`

## Minimal working pattern

Always simulate using `Simulink.SimulationInput` and `Simulink.SimulationOutput`:

```matlab
in = Simulink.SimulationInput('MyModel');
in = in.setModelParameter('StopTime', '10');
out = sim(in);
```

## Setting parameters

Use `SimulationInput` methods to configure the simulation:

```matlab
% Model-level parameters (StopTime, SolverType, SimulationMode, etc.)
in = in.setModelParameter('StopTime', '10', 'SolverType', 'Fixed-step');

% Block parameters — resolve path from blk_X ID (never type block names manually)
blkPath = Simulink.ID.getFullName('MyModel:5');
in = in.setBlockParameter(blkPath, 'Gain', '5');

% MATLAB workspace variables used by the model
in = in.setVariable('Kp', 1.2);
```

## Input signals

Pass input signals through Inport blocks using a `Simulink.SimulationData.Dataset`. Elements are matched to Inport blocks **by index position** — the first element maps to the Inport with port number 1, the second to port number 2, and so on.

```matlab
dt = 0.01;
N = 1000;
t = dt*(0:N)';
u = sin(2*pi*t);

ts = timeseries(u, t);

ds = Simulink.SimulationData.Dataset;
ds{1} = ts;

in = in.setExternalInput(ds);
out = sim(in);
```

You can also use `timetable` as an input format:

```matlab
secs = seconds(t);
tt = timetable(secs, u);

ds = Simulink.SimulationData.Dataset;
ds{1} = tt;

in = in.setExternalInput(ds);
```

## Discovering logged data

First, discover what kinds of logged data the model produces using `who`, then inspect signal names within `logsout`:

```matlab
in = Simulink.SimulationInput('MyModel');
out = sim(in);

% See what logging properties exist (logsout, yout, tout, etc.)
who(out)

% List individual signal names within logsout
disp(out.logsout.getElementNames);
```

## Accessing logged data

Logged signals are available through `out.logsout`. Access them directly by name:

```matlab
% Plot a logged signal
plot(out.logsout.get('signalName').Values)

% Get time and data separately
sig = out.logsout.get('signalName').Values;
plot(sig.Time, sig.Data)
```

## Multiple simulations

When running many simulations, create an array of `Simulink.SimulationInput` objects:

```matlab
in = repmat(Simulink.SimulationInput('MyModel'),N,1);
for k = 1:N
    in(k) = Simulink.SimulationInput('MyModel');
    in(k) = in(k).setVariable('gain', gains(k));
end
out = sim(in);
```

To enable fast restart for iterative sweeps (compiles the model only once):

```matlab
out = sim(in, 'UseFastRestart', 'on');
```

## Parallel simulation (parsim)

To run multiple simulations in parallel, use `parsim` instead of looping over `sim`:

```matlab
for k = 1:N
    in(k) = Simulink.SimulationInput('MyModel');
    in(k) = in(k).setVariable('gain', gains(k));
end
out = parsim(in);
```

`parsim` also supports `'UseFastRestart','on'` for faster batch runs.

## Guardrails

- **Never** use `set_param`, `load_system`, or `open_system` to drive simulation — `SimulationInput` replaces all of these.
- **Never** wrap `SimulationOutput` access in `try-catch` or `isfield` — `sim` either returns a valid object or throws. `SimulationOutput` has no `isfield` method.
- **Never** create unnecessary intermediate variables for logged data — access directly via `out.logsout.get('name').Values`.
- **Always** use `in`/`out` as variable names for `SimulationInput`/`SimulationOutput`.
- **Always** use `setExternalInput` with a `Dataset` — don't pass comma-separated lists of variables.

----

Copyright 2026 The MathWorks, Inc.

----