simulating-simulink-models
/simulating-simulink-models
Konfiguruje symulacje Simulinka bez zmiany modelu: nadpisuje parametry, robi serie parsim i zbiera wyniki.
- Autor
- matlab ↗
- Repozytorium
- simulink-agentic-toolkit ↗
- Licencja
- BSD-2-Clause
- Ostatnia zmiana repozytorium
- 21.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 2
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 1
Brak sygnałów. Repozytorium zmienione 21.10.2026, bez odwołań do wycofanych modeli i API.
BSD-2-Clause, otwarta.
Co robi i kiedy
Konfiguruje symulacje Simulinka bez zmiany modelu: nadpisuje parametry, robi serie parsim i zbiera wyniki.
Oryginalny opis (EN)
Configures Simulink simulations non-destructively using SimulationInput objects — parameter overrides without modifying the model, batch sweeps via parsim, custom input signals via Dataset, and simulation data retrieval via logsout. Use when running sim()/parsim() with setVariable, setBlockParameter, setExternalInput, or when performing parameter sweeps and multi-run analysis. Not needed for one-shot simulations without configuration.
Jak działa
- When to Use
- When NOT to Use
- Minimal working pattern
- Setting parameters
- Input signals
- Discovering logged data
- Accessing logged data
- Multiple simulations
- Parallel simulation (parsim)
- Guardrails
Podgląd SKILL.md
---
name: simulating-simulink-models
description: Configures Simulink simulations non-destructively using SimulationInput objects — parameter overrides without modifying the model, batch sweeps via parsim, custom input signals via Dataset, and simulation data retrieval via logsout. Use when running sim()/parsim() with setVariable, setBlockParameter, setExternalInput, or when performing parameter sweeps and multi-run analysis. Not needed for one-shot simulations without configuration.
license: https://www.mathworks.com/content/dam/mathworks/license/pmrl/license.md
metadata:
author: MathWorks
version: "1.2"
---
# 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.
----
Pliki w paczce (2)
- SKILL.md 6 KB
- manifest.yaml 1 KB
Wersje
| Repozytorium | Wynik | Licencja |
|---|---|---|
| Ta strona · matlab/simulink-agentic-toolkit | 100 | BSD-2-Clause |
| 3154410240smh-arch/aircraft-control-modeling | 100 | Apache-2.0 |
Migawka bazy z 13.11.2026 · wersja paczki dd04bc216036 (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100simulink-run-parallel-simulations
Uruchamia równolegle wiele symulacji Simulinka z parsim, batchsim i DesignStudy, np. do sweepu parametrów lub Monte Carlo. - 100simulink-linearize
Linearyzuje modele Simulinka do postaci liniowej LTI lub LPV, na przykład do analizy sterowania. - 95simulink-automation
Analizuje i modyfikuje modele Simulink przez MATLAB Engine: topologię, parametry i cykl życia modelu. - 100matlab-simulink
Pisze skrypty MATLAB i modele Simulink do układów sterowania, robotyki i miękkich obliczeń, z przejrzystą strukturą i analizą wyników. - 100roadrunner-scenario-simulating
Uruchamia symulacje scenariuszy RoadRunner z MATLAB i we współsymulacji z Simulinkiem, z obserwatorami, czujnikami i logami. - 95simulation-orchestrator
Prowadzi kampanie symulacji: przeglądy parametrów, partie zadań, śledzenie stanu i łączenie wyników z wielu uruchomień.