Przejdź do treści
Biblioteka skilli
Nauka i badania · Automatyzacja

simulating-simulink-models

/simulating-simulink-models

Konfiguruje symulacje Simulinka bez zmiany modelu: nadpisuje parametry, robi serie parsim i zbiera wyniki.

Licencja
BSD-2-Clause
Ostatnia zmiana repozytorium
21.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
2
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 21.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

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

  1. When to Use
  2. When NOT to Use
  3. Minimal working pattern
  4. Setting parameters
  5. Input signals
  6. Discovering logged data
  7. Accessing logged data
  8. Multiple simulations
  9. Parallel simulation (parsim)
  10. Guardrails
Sekcje z nagłówków SKILL.md, w oryginale · 153 linii, 648 słów
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

RepozytoriumWynikLicencja
Ta strona · matlab/simulink-agentic-toolkit100BSD-2-Clause
3154410240smh-arch/aircraft-control-modeling100Apache-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ń.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.