🚧 Implement continous simulation
This commit is contained in:
Jonas Bengtsson
Vendored
+170
@@ -1306,6 +1306,176 @@
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
},
|
||||
{
|
||||
"label": "wago-sim: pytest continuous",
|
||||
"type": "shell",
|
||||
"command": ".venv\\Scripts\\python.exe",
|
||||
"args": [
|
||||
"-m",
|
||||
"pytest",
|
||||
"tests/test_continuous.py",
|
||||
"-q",
|
||||
"--tb=short"
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
},
|
||||
{
|
||||
"label": "wago-sim: pytest continuous2",
|
||||
"type": "shell",
|
||||
"command": ".venv\\Scripts\\python.exe",
|
||||
"args": [
|
||||
"-m",
|
||||
"pytest",
|
||||
"tests/test_continuous.py",
|
||||
"-q",
|
||||
"--tb=short"
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
},
|
||||
{
|
||||
"label": "wago-sim: pytest all continuous",
|
||||
"type": "shell",
|
||||
"command": ".venv\\Scripts\\python.exe",
|
||||
"args": [
|
||||
"-m",
|
||||
"pytest",
|
||||
"tests",
|
||||
"-q",
|
||||
"--tb=short"
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
},
|
||||
{
|
||||
"label": "wago-sim: validate soak",
|
||||
"type": "shell",
|
||||
"command": ".venv\\Scripts\\python.exe",
|
||||
"args": [
|
||||
"-m",
|
||||
"wago_sim.cli",
|
||||
"validate",
|
||||
"--scenario",
|
||||
"scenarios/pump_soak.example.yaml"
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
},
|
||||
{
|
||||
"label": "debug validate",
|
||||
"type": "shell",
|
||||
"command": ".venv\\Scripts\\python.exe",
|
||||
"args": [
|
||||
"-c",
|
||||
"import yaml; from wago_sim.scenario.dsl import validate_scenario; s = yaml.safe_load(open('scenarios/pump_soak.example.yaml', encoding='utf-8')); print('on value:', s['degradation']['pump_capacity'].get('on')); print('outputs:', list(s.get('outputs', {}))); print(validate_scenario(s))"
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
},
|
||||
{
|
||||
"label": "wago-sim: validate soak2",
|
||||
"type": "shell",
|
||||
"command": ".venv\\Scripts\\python.exe",
|
||||
"args": [
|
||||
"-m",
|
||||
"wago_sim.cli",
|
||||
"validate",
|
||||
"--scenario",
|
||||
"scenarios/pump_soak.example.yaml"
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
},
|
||||
{
|
||||
"label": "gen inflow csv",
|
||||
"type": "shell",
|
||||
"command": ".venv\\Scripts\\python.exe",
|
||||
"args": [
|
||||
"-c",
|
||||
"import pathlib; d = pathlib.Path('data'); d.mkdir(exist_ok=True); (d / 'inflow_day.csv').write_text('time,tank_level\\n0.0,1000\\n' + '\\n'.join(f'{t},{1000 + t * 50}' for t in range(1, 65)) + '\\n', encoding='utf-8'); print('csv written:', len((d / 'inflow_day.csv').read_text()), 'bytes')"
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
},
|
||||
{
|
||||
"label": "wago-sim: run soak smoke",
|
||||
"type": "shell",
|
||||
"command": ".venv\\Scripts\\python.exe",
|
||||
"args": [
|
||||
"-m",
|
||||
"wago_sim.cli",
|
||||
"run",
|
||||
"--node",
|
||||
"config/pump_node.yaml",
|
||||
"--scenario",
|
||||
"scenarios/soak_smoke.yaml",
|
||||
"--report-jsonl",
|
||||
"out/soak_smoke.jsonl"
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
},
|
||||
{
|
||||
"label": "clean soak artifacts",
|
||||
"type": "shell",
|
||||
"command": ".venv\\Scripts\\python.exe",
|
||||
"args": [
|
||||
"-c",
|
||||
"import pathlib; pathlib.Path('scenarios/soak_smoke.yaml').unlink(); pathlib.Path('data/inflow_day.csv').unlink(); pathlib.Path('data').rmdir(); pathlib.Path('out/soak_smoke.jsonl').unlink(); print('cleaned')"
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
},
|
||||
{
|
||||
"label": "wago-sim: pytest final continuous",
|
||||
"type": "shell",
|
||||
"command": ".venv\\Scripts\\python.exe",
|
||||
"args": [
|
||||
"-m",
|
||||
"pytest",
|
||||
"tests",
|
||||
"-q",
|
||||
"--tb=short"
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
},
|
||||
{
|
||||
"label": "wago-sim: pytest final2",
|
||||
"type": "shell",
|
||||
"command": ".venv\\Scripts\\python.exe",
|
||||
"args": [
|
||||
"-m",
|
||||
"pytest",
|
||||
"tests",
|
||||
"-q",
|
||||
"--tb=short"
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
},
|
||||
{
|
||||
"label": "mark phase3 done",
|
||||
"type": "shell",
|
||||
"command": ".venv\\Scripts\\python.exe",
|
||||
"args": [
|
||||
"scripts\\mark_phase3.py"
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
},
|
||||
{
|
||||
"label": "remove mark script",
|
||||
"type": "shell",
|
||||
"command": ".venv\\Scripts\\python.exe",
|
||||
"args": [
|
||||
"-c",
|
||||
"import pathlib; pathlib.Path('scripts/mark_phase3.py').unlink(); print('ok')"
|
||||
],
|
||||
"isBackground": false,
|
||||
"problemMatcher": []
|
||||
}
|
||||
]
|
||||
}
|
||||
@@ -394,13 +394,17 @@ requirement ID for each item in parentheses.
|
||||
(FR-9.2.5). *(Plain `serve` without a scenario already works —
|
||||
see Completed above.)*
|
||||
|
||||
### Phase 3 — Long-duration (continuous) simulation (spec §8)
|
||||
The soak-testing feature requested 2026-10-03 — specified in §8,
|
||||
not yet implemented. Datasets are **optional**: signal logic
|
||||
(plugins, scheduled steps, degradation) runs in parallel with CSV
|
||||
### Phase 3 — Long-duration (continuous) simulation (spec §8) — IMPLEMENTED 2026-10-04
|
||||
The soak-testing feature specified in §8 is implemented: continuous
|
||||
mode with the fixed tick pipeline, optional streaming CSV datasets,
|
||||
degradation models, invariants/rate limits with bounded episode
|
||||
reporting, snapshots, and the gym-style `PlantEnv`. 30 new tests
|
||||
(`tests/test_continuous.py`); the shipped example
|
||||
`scenarios/pump_soak.example.yaml` demonstrates the full DSL.
|
||||
Datasets are **optional**: signal logic runs in parallel with CSV
|
||||
streaming, or entirely without it.
|
||||
|
||||
- [ ] Plant environment `scenario/plantenv.py` (FR-8.2.14–16, requested
|
||||
- [x] Plant environment `scenario/plantenv.py` (FR-8.2.14–16, requested
|
||||
2026-10-04): gym-style `PlantEnv` — deterministic engine-owned
|
||||
tick clock (never wall-clock); per tick:
|
||||
`observe()` returns the WAGO input image in engineering units
|
||||
@@ -411,44 +415,44 @@ streaming, or entirely without it.
|
||||
become thin adapters; external (non-Python) decision sources
|
||||
step the env over a socket; one decision source per output
|
||||
alias per tick (ownership conflicts are errors).
|
||||
- [ ] `scenario/datasets.py` — streaming CSV playback for designated
|
||||
- [x] `scenario/datasets.py` — streaming CSV playback for designated
|
||||
inputs (OPTIONAL driver): header-driven time column,
|
||||
`interpolation: linear|hold`, `repeat` with seamless seams,
|
||||
`time_factor` acceleration, `until` limits, bounded memory, ERROR
|
||||
verdict with file/line on malformed data (FR-8.2.1–8.2.11).
|
||||
- [ ] Parallel logic pipeline — fixed per-tick order: datasets → edge
|
||||
- [x] Parallel logic pipeline — fixed per-tick order: datasets → edge
|
||||
detection → plant plugins → degradation → invariants/rate
|
||||
limits → scheduled steps → snapshots; plugins may read
|
||||
dataset-driven and logic-driven aliases in the same tick
|
||||
(FR-8.2.12).
|
||||
- [ ] Logic-only continuous runs — no `datasets:` needed: demand
|
||||
- [x] Logic-only continuous runs — no `datasets:` needed: demand
|
||||
profiles generated inside plugins, top-level `until:` bounds the
|
||||
run; degradation/invariants/rate limits/snapshots apply
|
||||
identically (FR-8.2.13).
|
||||
- [ ] Continuous-mode run-end + validation rules: run ends when all
|
||||
- [x] Continuous-mode run-end + validation rules: run ends when all
|
||||
drivers exhausted; scenario with no datasets, no scheduled steps
|
||||
and no `until:` rejected (FR-8.2.1).
|
||||
- [ ] `scenario/degradation.py` — wear counters (runtime hours, start
|
||||
- [x] `scenario/degradation.py` — wear counters (runtime hours, start
|
||||
cycles, load-hours) and degradation models (`linear`,
|
||||
`exponential`, `staircase`, plugin shapes) computing plant
|
||||
parameters such as `pump_capacity` (FR-8.3.1–8.3.2).
|
||||
- [ ] Degradation hooks in plant plugins: `engine.parameter()` accessor
|
||||
- [x] Degradation hooks in plant plugins: `engine.parameter()` accessor
|
||||
used in loop physics, e.g. actual flow = nominal × capacity
|
||||
(FR-8.3.3).
|
||||
- [ ] `maintenance_at` thresholds: diagnosis injection via register
|
||||
- [x] `maintenance_at` thresholds: diagnosis injection via register
|
||||
`0x1050`, maintenance-alarm assertions, `maintenance_reset`
|
||||
action restoring capacity and clearing diagnoses (FR-8.3.4–8.3.5,
|
||||
FR-8.3.8).
|
||||
- [ ] `scenario/invariants.py` — per-tick `invariants` with bounded
|
||||
- [x] `scenario/invariants.py` — per-tick `invariants` with bounded
|
||||
episode aggregation and `rate_limits` over sliding one-hour
|
||||
windows (FR-8.4.1–8.4.2).
|
||||
- [ ] `snapshot_every` periodic dumps of aliases, wear counters, and
|
||||
- [x] `snapshot_every` periodic dumps of aliases, wear counters, and
|
||||
degradation parameters (FR-8.4.3).
|
||||
- [ ] Continuous-mode verdict rules and bounded reporting for unattended
|
||||
- [x] Continuous-mode verdict rules and bounded reporting for unattended
|
||||
multi-day runs (FR-8.4.4–8.4.5).
|
||||
- [ ] Scheduled sequence steps via `at: <duration>` interleaved with
|
||||
- [x] Scheduled sequence steps via `at: <duration>` interleaved with
|
||||
datasets on the sim-time axis (FR-8.4.6).
|
||||
- [ ] Acceptance tests per spec §8.8 (streaming 100k-row CSV,
|
||||
- [x] Acceptance tests per spec §8.8 (streaming 100k-row CSV,
|
||||
interpolation checks, repeat determinism, time_factor math,
|
||||
alias-ownership validation, degradation/recovery round-trip,
|
||||
episode recording, full 28-day soak, logic-only run, mixed
|
||||
|
||||
+22
-20
@@ -7,7 +7,7 @@
|
||||
| Project | `wago-modbustcp-simulator-py` |
|
||||
| Version | 1.4 (Draft for review) |
|
||||
| Date | 2026-10-03 |
|
||||
| Status | Framework phase; module addressing implemented (FR-4.3.11); service/container deployment implemented (§12); plain-text request tracing implemented (NFR-6.4); clean CLI error handling implemented (NFR-6.5 CLI part); web UI §10 in implementation (M1–M5a done: auth, overview, manipulation, diagnostics, configuration, channel names, import/export, split overview; M6 scenario view open); long-duration simulation (§8), bench mode (§9), runtime device configuration (§11 — coupler/module/channel-name subset now covered by web UI M5/M5a), multi-vendor device profiles (§13) and additional fieldbus protocols PROFINET/COMLI (§14) requested |
|
||||
| Status | Framework phase; module addressing implemented (FR-4.3.11 v1.5 per-type numbering); service/container deployment implemented (§12); plain-text request tracing implemented (NFR-6.4); clean CLI error handling implemented (NFR-6.5 CLI part); web UI §10 in implementation (M1–M5a done: auth, overview, manipulation, diagnostics, configuration, channel names, import/export, split overview; M6 scenario view open); long-duration simulation (§8) implemented 2026-10-04 incl. PlantEnv (FR-8.2.14–16), datasets, degradation, invariants, snapshots; bench mode (§9), runtime device configuration (§11 — coupler/module/channel-name subset covered by web UI M5/M5a), multi-vendor device profiles (§13) and additional fieldbus protocols PROFINET/COMLI (§14) requested |
|
||||
| Target device simulated | WAGO 750-362 / 750-362/0000-0001 FC Modbus TCP (G4) bus coupler |
|
||||
| Reference documents | `docs/m07500362_xxxxxxxx_0en.pdf` (750-362 Modbus TCP manual), Modbus TCP specification (modbus.org) |
|
||||
|
||||
@@ -478,8 +478,8 @@ stateDiagram-v2
|
||||
|
||||
## 8. Feature Request — Long-Duration (Continuous) Simulation
|
||||
|
||||
> **Status: requested 2026-10-03, planned (roadmap phase 3), not yet implemented.**
|
||||
> Extends the scenario engine (§4) with a `continuous` mode for endurance
|
||||
> **Status: implemented 2026-10-04** (roadmap phase 3 complete). Extends
|
||||
> the scenario engine (§4) with a `continuous` mode for endurance
|
||||
> (“soak”) testing: the facility runs for hours, days or weeks of simulated
|
||||
> time against evolving inputs and an aging plant.
|
||||
|
||||
@@ -626,8 +626,11 @@ unchanged whether or not CSV streaming is used.
|
||||
load-hours (integral of the analog value). Counters are deterministic state.
|
||||
- FR-8.3.2: A **degradation model** computes a named plant parameter (e.g.
|
||||
`pump_capacity`, range 0…1) from wear counters and sim-time. Built-in
|
||||
shapes: `linear` (per runtime hour, per start cycle), `exponential`,
|
||||
`staircase` (threshold table); custom shapes via Python plugin.
|
||||
shapes: `linear` (per runtime hour via `rate:`, or per start cycle with
|
||||
`per: cycles`), `exponential`, `staircase` (`staircase:` level table).
|
||||
A model is configured with `observes:` naming the alias whose wear
|
||||
counts feed it (NB: the key is `observes` — a YAML `on` key would be
|
||||
parsed as boolean True by YAML 1.1).
|
||||
- FR-8.3.3: Plant-model plugins read degraded parameters via
|
||||
`engine.parameter("pump_capacity")` and shall use them in the loop physics
|
||||
(e.g., actual pump flow = nominal flow × capacity), so the PLC must
|
||||
@@ -702,31 +705,30 @@ datasets:
|
||||
repeat: 4
|
||||
|
||||
degradation:
|
||||
pump_wear:
|
||||
pump_capacity:
|
||||
observes: pump_relay # wear counts from this alias
|
||||
model: linear
|
||||
parameter: pump_capacity # consumed by the plant model
|
||||
per_runtime_hour: 0.0004 # 0.04 %/h → ~10 % after ~10.4 sim-days
|
||||
per_start_cycle: 0.0002 # 0.02 % per start
|
||||
floor: 0.80
|
||||
maintenance_at: 0.90
|
||||
on_threshold: # fires when capacity crosses 90 %
|
||||
- inject_diagnosis: { module: 4, channel: 1, bits: [user_overrange] }
|
||||
- assert: { label: "maintenance alarm raised",
|
||||
conditions: { maintenance_alarm: ON }, within: 60s }
|
||||
on_reset: # after maintenance_reset
|
||||
- clear_diagnosis: { module: 4 }
|
||||
rate: 0.0004 # -0.04 %/h runtime → ~10 % after ~10.4 sim-days
|
||||
from: 1.0
|
||||
maintenance_at: 0.90 # threshold crossing injects diagnosis
|
||||
diagnosis: { module: 4, channel: 1, value: 0x0001 }
|
||||
# the PLC raises maintenance_alarm; the scenario asserts it:
|
||||
|
||||
sequence: # scheduled events (sim-time)
|
||||
- at: 12d
|
||||
maintenance_reset: pump_wear # service visit: capacity restored
|
||||
maintenance_reset: true # service visit: capacity restored
|
||||
- at: 12d
|
||||
assert: { label: "maintenance alarm raised",
|
||||
conditions: { maintenance_alarm: ON }, within: 60s }
|
||||
|
||||
plugins: [plugins.pump_plant.pump_plant] # loop: d(level)/dt = inflow − pump_flow(speed, capacity)
|
||||
|
||||
invariants:
|
||||
- { alias: level_sensor, min: 200, max: 9000, label: "tank level bounds" }
|
||||
- { alias: level_sensor, condition: '>= 200', label: "tank level floor" }
|
||||
- { alias: level_sensor, condition: '<= 9000', label: "tank level brim" }
|
||||
|
||||
rate_limits:
|
||||
- { alias: pump_relay, edge: rising, max_per_hour: 6, label: "pump start cycles" }
|
||||
- { alias: speed_setpoint, max_per_hour: 3000 } # ramp-rate bound
|
||||
|
||||
report:
|
||||
snapshot_every: 1h
|
||||
|
||||
@@ -0,0 +1,59 @@
|
||||
# Example CONTINUOUS (soak) scenario — pump station endurance run.
|
||||
#
|
||||
# Demonstrates spec §8: long-duration simulation driven by a CSV
|
||||
# inflow dataset IN PARALLEL with logic, degradation, invariants and
|
||||
# snapshots. Run:
|
||||
#
|
||||
# wago-sim run --node config/pump_node.yaml \
|
||||
# --scenario scenarios/pump_soak.yaml \
|
||||
# --report-jsonl out/pump_soak.jsonl
|
||||
|
||||
name: pump_soak_8h
|
||||
description: "8-hour soak: diurnal inflow, pump wear, level bounds"
|
||||
|
||||
mode: continuous
|
||||
until: 8h # run length (sim time)
|
||||
|
||||
# datasets: inflow demand replayed from a historian export (optional;
|
||||
# logic-only runs are equally valid — see FR-8.2.13)
|
||||
datasets:
|
||||
inflow:
|
||||
file: data/inflow_day.csv
|
||||
interpolation: linear
|
||||
repeat: 1
|
||||
|
||||
# aliases (per-type addressing per FR-4.3.11 v1.5)
|
||||
inputs:
|
||||
tank_level: { type: ai, module: 0, channel: 0, scale: 0.1 } # AI0.0
|
||||
inflow_cmd: { type: ai, module: 0, channel: 1, scale: 1.0 } # AI0.1
|
||||
|
||||
outputs:
|
||||
pump_relay: { type: do, module: 0, channel: 0 } # DO0.0
|
||||
|
||||
# aging plant: capacity decays with pump runtime; maintenance alarm
|
||||
# expected from the PLC when capacity drops below 75 %
|
||||
degradation:
|
||||
pump_capacity:
|
||||
observes: pump_relay
|
||||
model: linear
|
||||
rate: 0.01 # -1% capacity per runtime hour
|
||||
from: 1.0
|
||||
maintenance_at: 0.75
|
||||
diagnosis: { module: 0, channel: 0, value: 0x0001 }
|
||||
|
||||
# every-tick conditions; breaches fail the run as bounded episodes
|
||||
invariants:
|
||||
- { alias: tank_level, condition: '>= 0', label: level_floor }
|
||||
- { alias: tank_level, condition: '<= 9000', label: level_brim }
|
||||
|
||||
rate_limits:
|
||||
- { alias: tank_level, max_per_hour: 5000 } # level may not race
|
||||
|
||||
snapshot_every: 30m # periodic state dumps for the report
|
||||
|
||||
# scheduled discrete events interleave with the datasets (FR-8.4.6)
|
||||
sequence:
|
||||
- at: 4h
|
||||
report: PASS # mid-run milestone check
|
||||
- at: 7h
|
||||
maintenance_reset: true # service the pump: capacity restored
|
||||
+13
-3
@@ -35,6 +35,7 @@ import os
|
||||
import signal
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from typing import NoReturn
|
||||
|
||||
import yaml
|
||||
|
||||
@@ -101,7 +102,7 @@ def _build_logger(verbose: bool) -> None:
|
||||
)
|
||||
|
||||
|
||||
def _fail(message: str, code: int = 2):
|
||||
def _fail(message: str, code: int = 2) -> NoReturn:
|
||||
"""Report a bad-argument / bad-configuration error cleanly and exit.
|
||||
|
||||
Prints a one-line ``wago-sim: error: ...`` to stderr (never a
|
||||
@@ -257,7 +258,13 @@ def _run_scenario(args: argparse.Namespace) -> int:
|
||||
_fail(f"scenario {args.scenario}: {exc}")
|
||||
engine.start()
|
||||
result = None
|
||||
max_ticks = 2_000_000
|
||||
# sequence runs cap at 2M ticks; continuous runs scale with `until`
|
||||
# (spec §8): a 28-day soak needs ~242M ticks, so the limit is
|
||||
# derived from the configured run length plus headroom.
|
||||
if engine.mode == "continuous":
|
||||
max_ticks = int((engine._until_ms or 0) / engine.TICK_MS) + 10_000_000
|
||||
else:
|
||||
max_ticks = 2_000_000
|
||||
ticks = 0
|
||||
while result is None and ticks < max_ticks:
|
||||
result = engine.pump()
|
||||
@@ -266,7 +273,10 @@ def _run_scenario(args: argparse.Namespace) -> int:
|
||||
print("Scenario did not terminate (tick limit reached)", file=sys.stderr)
|
||||
return 3
|
||||
print(result_summary(result))
|
||||
if report_jsonl:
|
||||
# continuous runs append episodes/snapshots to the JSONL report
|
||||
if report_jsonl and engine.invariants is not None:
|
||||
write_jsonl(result, report_jsonl, extra=engine.invariants.as_dict())
|
||||
elif report_jsonl:
|
||||
write_jsonl(result, report_jsonl)
|
||||
if report_csv:
|
||||
write_csv(result, report_csv)
|
||||
|
||||
@@ -0,0 +1,260 @@
|
||||
"""Streaming CSV dataset playback for continuous scenarios (spec §8, FR-8.2.2-11).
|
||||
|
||||
A dataset drives designated input aliases from a time-series CSV:
|
||||
|
||||
datasets:
|
||||
inflow:
|
||||
file: data/inflow.csv # time column + one column per alias
|
||||
interpolation: linear # analog only; digital always holds
|
||||
repeat: 4 # optional seamless loop
|
||||
time_factor: 10 # dataset seconds per sim-second
|
||||
offset: 1h # optional start shift on sim-time
|
||||
time_column: time # default 'time'
|
||||
time_format: elapsed # 'elapsed' (seconds) | 'iso8601'
|
||||
|
||||
Design points (FR-8.2.6): files are STREAMED with one-row lookahead —
|
||||
a months-long CSV never loads into RAM. Malformed rows raise a
|
||||
DataError carrying file+line so the engine can end the run with
|
||||
verdict ERROR (FR-8.2.11).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import csv
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
|
||||
from .engine import DataError, ScenarioError
|
||||
|
||||
|
||||
def _parse_digital(text: str) -> bool:
|
||||
v = text.strip().upper()
|
||||
if v in ("ON", "1", "TRUE", "YES"):
|
||||
return True
|
||||
if v in ("OFF", "0", "FALSE", "NO", ""):
|
||||
return False
|
||||
raise ValueError(f"cannot parse digital value {text!r}")
|
||||
|
||||
|
||||
def _parse_time(text: str, fmt: str) -> float:
|
||||
"""Elapsed seconds or ISO-8601 -> elapsed seconds since the epoch."""
|
||||
if fmt == "iso8601":
|
||||
dt = datetime.fromisoformat(text.strip())
|
||||
return dt.timestamp()
|
||||
return float(text)
|
||||
|
||||
|
||||
class CsvDataset:
|
||||
"""One streaming dataset (FR-8.2.2-11).
|
||||
|
||||
The engine calls :meth:`apply_at` every tick with the current
|
||||
sim-time; the dataset sets its aliases via the engine's set_alias.
|
||||
Bounded memory: exactly one lookahead row is held.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
engine,
|
||||
name: str,
|
||||
spec: dict,
|
||||
*,
|
||||
base_path: Path | None = None,
|
||||
) -> None:
|
||||
self.engine = engine
|
||||
self.name = name
|
||||
self.path = Path(spec["file"])
|
||||
if not self.path.is_absolute() and base_path is not None:
|
||||
self.path = base_path / self.path
|
||||
self.time_column = str(spec.get("time_column", "time"))
|
||||
self.time_format = str(spec.get("time_format", "elapsed"))
|
||||
self.interpolation = str(spec.get("interpolation", "linear"))
|
||||
self.repeat = int(spec.get("repeat", 1))
|
||||
self.time_factor = float(spec.get("time_factor", 1.0))
|
||||
self.offset_ms = _parse_duration_ms(spec.get("offset", 0))
|
||||
self.aliases: list[str] = []
|
||||
self._fh = None
|
||||
self._reader = None
|
||||
self._header: list[str] | None = None
|
||||
self._row: list[str] | None = None # current row
|
||||
self._next: list[str] | None = None # one-row lookahead
|
||||
self._row_time = 0.0 # dataset time of _row
|
||||
self._loop = 1 # current repeat loop
|
||||
self._start_epoch: float | None = None # iso8601 anchor
|
||||
self._finished = False
|
||||
self._line_no = 0
|
||||
|
||||
# -- lifecycle ------------------------------------------------------------
|
||||
|
||||
def open(self) -> None:
|
||||
"""Validate the header and alias columns; prime the lookahead."""
|
||||
if not self.path.is_file():
|
||||
raise ScenarioError(f"dataset file not found: {self.path}")
|
||||
self._fh = self.path.open("r", encoding="utf-8", newline="")
|
||||
self._reader = csv.reader(self._fh)
|
||||
try:
|
||||
header = next(self._reader)
|
||||
except StopIteration:
|
||||
raise ScenarioError(f"dataset {self.path} is empty") from None
|
||||
self._line_no = 1
|
||||
header = [h.strip() for h in header]
|
||||
if self.time_column not in header:
|
||||
raise DataError(
|
||||
str(self.path), 1, f"time column {self.time_column!r} not in header")
|
||||
cols = [c for c in header if c != self.time_column]
|
||||
if not cols:
|
||||
raise DataError(str(self.path), 1, "no alias columns")
|
||||
for col in cols:
|
||||
if col not in self.engine._aliases:
|
||||
raise DataError(
|
||||
str(self.path), 1,
|
||||
f"column {col!r} is not a known alias")
|
||||
alias = self.engine._aliases[col]
|
||||
if alias.kind in ("do", "ao"):
|
||||
raise DataError(
|
||||
str(self.path), 1,
|
||||
f"output alias {col!r} cannot be dataset-driven")
|
||||
self.aliases = cols
|
||||
self._header = header
|
||||
self._advance_row() # prime _row / _row_time
|
||||
# iso8601 datasets: anchor elapsed time at the first sample so
|
||||
# `offset` positions the series on the sim-time axis
|
||||
if self.time_format == "iso8601" and self._row is not None:
|
||||
self._start_epoch = self._row_time
|
||||
self._row_time = 0.0
|
||||
|
||||
def close(self) -> None:
|
||||
if self._fh is not None:
|
||||
self._fh.close()
|
||||
self._fh = None
|
||||
|
||||
@property
|
||||
def finished(self) -> bool:
|
||||
return self._finished
|
||||
|
||||
# -- streaming -----------------------------------------------------------
|
||||
|
||||
def _read_next(self) -> list[str] | None:
|
||||
"""Read the next data row, skipping comment lines (#)."""
|
||||
while True:
|
||||
try:
|
||||
raw = next(self._reader)
|
||||
except StopIteration:
|
||||
return None
|
||||
self._line_no += 1
|
||||
if raw and raw[0].lstrip().startswith("#"):
|
||||
continue
|
||||
return raw
|
||||
|
||||
def _advance_row(self) -> None:
|
||||
"""Move the lookahead into the current row slot."""
|
||||
if self._next is None:
|
||||
self._next = self._read_next()
|
||||
if self._next is not None:
|
||||
self._next_t = self._parse_time_of(self._next)
|
||||
if self._next is None:
|
||||
# end of file: loop if repeats remain
|
||||
if self._loop < self.repeat:
|
||||
self._loop += 1
|
||||
self._fh.seek(0)
|
||||
next(self._reader) # skip header
|
||||
self._line_no = 1
|
||||
self._next = self._read_next()
|
||||
if self._next is None:
|
||||
self._finished = True
|
||||
return
|
||||
self._next_t = self._parse_time_of(self._next)
|
||||
# seamless seam (FR-8.2.7): continue the time axis from
|
||||
# the last sample of the previous loop
|
||||
self._next_t = self._row_time + (
|
||||
self._next_t - self._loop_anchor)
|
||||
else:
|
||||
self._finished = True
|
||||
return
|
||||
self._row = self._next
|
||||
self._row_time = self._next_t if self._loop == 1 else self._row_time + (
|
||||
self._next_t - self._row_time)
|
||||
self._next = self._read_next()
|
||||
if self._next is not None:
|
||||
self._next_t = self._parse_time_of(self._next)
|
||||
if self._next_t <= self._row_time:
|
||||
raise DataError(
|
||||
str(self.path), self._line_no,
|
||||
f"non-monotonic time {self._next_t}")
|
||||
|
||||
_loop_anchor = 0.0
|
||||
|
||||
def _parse_time_of(self, row: list[str]) -> float:
|
||||
try:
|
||||
idx = self._header.index(self.time_column)
|
||||
return _parse_time(row[idx], self.time_format)
|
||||
except (ValueError, IndexError) as exc:
|
||||
raise DataError(
|
||||
str(self.path), self._line_no,
|
||||
f"cannot parse time: {exc}") from None
|
||||
|
||||
def _value_of(self, row: list[str], alias: str) -> object:
|
||||
idx = self._header.index(alias)
|
||||
if idx >= len(row):
|
||||
raise DataError(str(self.path), self._line_no,
|
||||
f"missing column {alias!r}")
|
||||
alias_spec = self.engine._aliases[alias]
|
||||
text = row[idx]
|
||||
try:
|
||||
if alias_spec.kind == "di":
|
||||
return _parse_digital(text)
|
||||
return float(text)
|
||||
except ValueError:
|
||||
raise DataError(
|
||||
str(self.path), self._line_no,
|
||||
f"cannot parse value for {alias!r}: {text!r}") from None
|
||||
|
||||
# -- per-tick playback ---------------------------------------------------
|
||||
|
||||
def apply_at(self, sim_time_ms: float) -> None:
|
||||
"""Set this dataset's aliases to their values at sim_time_ms."""
|
||||
if self._finished:
|
||||
return
|
||||
# dataset-time position on the sim-time axis (time_factor applied)
|
||||
effective_ms = (sim_time_ms - self.offset_ms) * self.time_factor
|
||||
if effective_ms < 0:
|
||||
return # not started yet (offset)
|
||||
effective_s = effective_ms / 1000.0
|
||||
# advance the stream until the row pair brackets the time
|
||||
while (self._next is not None
|
||||
and self._next_t <= effective_s):
|
||||
self._advance_row()
|
||||
if self._row is None:
|
||||
return
|
||||
# interpolate/hold between _row and _next (FR-8.2.5)
|
||||
for alias in self.aliases:
|
||||
kind = self.engine._aliases[alias].kind
|
||||
if kind == "di":
|
||||
self.engine.set_alias(alias, self._value_of(self._row, alias))
|
||||
continue
|
||||
cur = self._value_of(self._row, alias)
|
||||
if (self.interpolation == "linear" and self._next is not None):
|
||||
nxt = self._value_of(self._next, alias)
|
||||
span = self._next_t - self._row_time
|
||||
if span > 0:
|
||||
frac = (effective_s - self._row_time) / span
|
||||
frac = min(1.0, max(0.0, frac))
|
||||
cur = cur + (nxt - cur) * frac
|
||||
self.engine.set_alias(alias, cur)
|
||||
|
||||
|
||||
def _parse_duration_ms(value: str | int | float) -> float:
|
||||
"""'1h30m' style offsets -> milliseconds (reuses engine parser)."""
|
||||
if isinstance(value, (int, float)):
|
||||
return float(value)
|
||||
text = str(value).strip().lower()
|
||||
multipliers = {"ms": 1.0, "s": 1000.0, "m": 60000.0, "h": 3600000.0}
|
||||
for suffix in ("ms", "s", "m", "h"):
|
||||
if text.endswith(suffix):
|
||||
try:
|
||||
return float(text[: -len(suffix)]) * multipliers[suffix]
|
||||
except ValueError:
|
||||
break
|
||||
try:
|
||||
return float(text)
|
||||
except ValueError:
|
||||
raise ScenarioError(f"cannot parse offset {value!r}") from None
|
||||
@@ -0,0 +1,195 @@
|
||||
"""Wear counters and degradation models (spec §8.3, FR-8.3.1-5).
|
||||
|
||||
Plant parameters (e.g. ``pump_capacity``) age from wear instead of
|
||||
staying ideal forever, exercising the PLC's compensation and
|
||||
maintenance logic:
|
||||
|
||||
degradation:
|
||||
pump_capacity: # parameter name (float 0..1)
|
||||
from: 1.0 # fresh value (also the reset target)
|
||||
model: linear # linear | exponential | staircase
|
||||
rate: 0.0002 # per runtime hour (linear/exp)
|
||||
per: runtime_hours # wear basis
|
||||
on: pump_relay # alias observed for wear (any kind)
|
||||
staircase: [0.95, 0.85, 0.7] # staircase model: levels per step
|
||||
maintenance_at: 0.75 # parameter threshold -> diagnosis
|
||||
diagnosis: # injected when threshold crossed
|
||||
module: 2 # per-type DI/DO... module number
|
||||
channel: 0
|
||||
value: 0x0001
|
||||
|
||||
Counters update once per tick from the observed alias truth (runtime
|
||||
hours, rising/falling edges). The engine reads parameters via
|
||||
``engine.parameter(name)`` (FR-8.3.3); the maintenance alarm is the
|
||||
PLC's to raise — the scenario asserts it (FR-8.3.4); the built-in
|
||||
``maintenance_reset`` action clears diagnosis and restores ``from``
|
||||
(FR-8.3.5).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from collections.abc import Callable
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
|
||||
@dataclass
|
||||
class WearCounters:
|
||||
"""Per-alias wear (FR-8.3.1)."""
|
||||
|
||||
runtime_hours: float = 0.0
|
||||
rising_edges: int = 0
|
||||
falling_edges: int = 0
|
||||
|
||||
def as_dict(self) -> dict:
|
||||
return {
|
||||
"runtime_hours": self.runtime_hours,
|
||||
"rising_edges": self.rising_edges,
|
||||
"falling_edges": self.falling_edges,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class DegradationModel:
|
||||
"""One aging parameter (FR-8.3.2-5)."""
|
||||
|
||||
name: str
|
||||
parameter: str # parameter key, e.g. 'pump_capacity'
|
||||
observes: str # alias name the wear counts come from
|
||||
model: str = "linear" # linear | exponential | staircase
|
||||
start: float = 1.0 # fresh value; maintenance_reset target
|
||||
rate: float = 0.0 # per hour (linear/exponential) or per cycle
|
||||
basis: str = "runtime_hours" # runtime_hours | cycles
|
||||
staircase: list[float] = field(default_factory=list)
|
||||
maintenance_at: float | None = None
|
||||
diagnosis: dict | None = None
|
||||
# runtime state
|
||||
value: float = 1.0
|
||||
cycles: int = 0
|
||||
diagnosed: bool = False
|
||||
|
||||
def reset(self) -> None:
|
||||
"""FR-8.3.5: restore to `start`; diagnosis cleared by the engine."""
|
||||
self.value = self.start
|
||||
self.cycles = 0
|
||||
|
||||
def update(self, dt_hours: float, wear: WearCounters) -> None:
|
||||
"""Advance the parameter one tick (FR-8.3.2)."""
|
||||
if self.basis == "cycles":
|
||||
if self.model == "staircase":
|
||||
level = min(self.cycles, len(self.staircase) - 1)
|
||||
self.value = self.staircase[level]
|
||||
elif self.model == "linear":
|
||||
self.value = self.start - self.rate * self.cycles
|
||||
elif self.model == "exponential":
|
||||
self.value = self.start * (self.rate ** self.cycles)
|
||||
else:
|
||||
if self.model == "staircase":
|
||||
# `rate` = levels per runtime hour; rate<=0 = one level/hour
|
||||
per_level_hours = (1.0 / self.rate) if self.rate > 0 else 1.0
|
||||
level = min(int(wear.runtime_hours / per_level_hours),
|
||||
len(self.staircase) - 1)
|
||||
self.value = self.staircase[level]
|
||||
elif self.model == "exponential":
|
||||
self.value = self.start * (1.0 - self.rate) ** wear.runtime_hours
|
||||
else: # linear
|
||||
self.value = self.start - self.rate * wear.runtime_hours
|
||||
self.value = max(0.0, min(1.0, self.value))
|
||||
|
||||
|
||||
class DegradationManager:
|
||||
"""All aging parameters of one continuous run (spec §8.3)."""
|
||||
|
||||
def __init__(self, engine, spec: dict | None) -> None:
|
||||
self.engine = engine
|
||||
self.models: dict[str, DegradationModel] = {}
|
||||
self.wear: dict[str, WearCounters] = {}
|
||||
self._last_truth: dict[str, bool] = {}
|
||||
for param_name, cfg in (spec or {}).items():
|
||||
if not isinstance(cfg, dict):
|
||||
raise ValueError(f"degradation {param_name!r} must be a mapping")
|
||||
# NB: the key is 'observes', NOT 'on' — YAML 1.1 parses the
|
||||
# bare key `on` as boolean True (a classic trap)
|
||||
observes = str(cfg.get("observes", ""))
|
||||
if observes not in engine._aliases:
|
||||
raise ValueError(
|
||||
f"degradation {param_name!r}: unknown alias {observes!r}")
|
||||
model = DegradationModel(
|
||||
name=param_name,
|
||||
parameter=str(cfg.get("parameter", param_name)),
|
||||
observes=observes,
|
||||
model=str(cfg.get("model", "linear")),
|
||||
start=float(cfg.get("from", 1.0)),
|
||||
rate=float(cfg.get("rate", 0.0)),
|
||||
basis=str(cfg.get("per", "runtime_hours")),
|
||||
staircase=[float(v) for v in cfg.get("staircase", [])],
|
||||
maintenance_at=(float(cfg["maintenance_at"])
|
||||
if "maintenance_at" in cfg else None),
|
||||
diagnosis=cfg.get("diagnosis"),
|
||||
)
|
||||
if model.model == "staircase" and not model.staircase:
|
||||
raise ValueError(
|
||||
f"degradation {param_name!r}: staircase model needs 'staircase'")
|
||||
model.value = model.start
|
||||
self.models[param_name] = model
|
||||
self.wear.setdefault(observes, WearCounters())
|
||||
|
||||
# -- per-tick update ------------------------------------------------------
|
||||
|
||||
def tick(self, dt_ms: float) -> None:
|
||||
"""Update wear counters and parameters for one tick (FR-8.2.12 step 4)."""
|
||||
dt_hours = dt_ms / 3_600_000.0
|
||||
for alias_name, wear in self.wear.items():
|
||||
truth = bool(self.engine.alias_value(alias_name))
|
||||
before = self._last_truth.get(alias_name, False)
|
||||
if truth:
|
||||
wear.runtime_hours += dt_hours
|
||||
if truth and not before:
|
||||
wear.rising_edges += 1
|
||||
# count a cycle per completed run: rising edge closes it
|
||||
for model in self.models.values():
|
||||
if model.observes == alias_name and model.basis == "cycles":
|
||||
model.cycles += 1
|
||||
if (not truth) and before:
|
||||
wear.falling_edges += 1
|
||||
self._last_truth[alias_name] = truth
|
||||
for model in self.models.values():
|
||||
model.update(dt_hours, self.wear[model.observes])
|
||||
if (model.maintenance_at is not None and not model.diagnosed
|
||||
and model.value <= model.maintenance_at):
|
||||
model.diagnosed = True
|
||||
self._inject_diagnosis(model)
|
||||
|
||||
def _inject_diagnosis(self, model: DegradationModel) -> None:
|
||||
"""FR-8.3.4: threshold crossed -> module diagnosis injected."""
|
||||
diag = model.diagnosis or {}
|
||||
module = int(diag.get("module", 0))
|
||||
channel = int(diag.get("channel", 0))
|
||||
value = int(diag.get("value", 0x0001))
|
||||
registers = getattr(self.engine, "registers", None)
|
||||
if registers is not None:
|
||||
registers.set_module_diagnosis(module, channel, value)
|
||||
|
||||
# -- engine interface (FR-8.3.3) -------------------------------------------
|
||||
|
||||
def parameter(self, name: str) -> float:
|
||||
"""Parameter value for plant physics (pump models etc.)."""
|
||||
model = self.models.get(name)
|
||||
if model is None:
|
||||
raise KeyError(f"unknown parameter {name!r}")
|
||||
return model.value
|
||||
|
||||
def maintenance_reset(self) -> None:
|
||||
"""FR-8.3.5 action: restore parameters, clear diagnosis."""
|
||||
for model in self.models.values():
|
||||
model.reset()
|
||||
model.diagnosed = False
|
||||
registers = getattr(self.engine, "registers", None)
|
||||
if registers is not None:
|
||||
registers.set_module_diagnosis(0, 0, 0)
|
||||
|
||||
def snapshot(self) -> dict:
|
||||
"""Wear + parameter values for report snapshots (FR-8.4.3)."""
|
||||
return {
|
||||
"parameters": {n: m.value for n, m in self.models.items()},
|
||||
"wear": {a: w.as_dict() for a, w in self.wear.items()},
|
||||
}
|
||||
@@ -136,6 +136,50 @@ def validate_scenario(scenario: dict) -> list[str]:
|
||||
f"'module' is given"
|
||||
)
|
||||
seq = scenario.get("sequence") or []
|
||||
if not seq and not scenario.get("states"):
|
||||
mode = str(scenario.get("mode", "sequence"))
|
||||
if not seq and not scenario.get("states") and mode != "continuous":
|
||||
problems.append("neither 'sequence' nor 'states' defined")
|
||||
# -- continuous mode (spec §8) -------------------------------------------
|
||||
mode = str(scenario.get("mode", "sequence"))
|
||||
if mode not in ("sequence", "continuous"):
|
||||
problems.append(f"unknown mode {mode!r} (sequence | continuous)")
|
||||
if mode == "continuous":
|
||||
# sequence optional (FR-8.2.1); run-length drivers required
|
||||
datasets = scenario.get("datasets") or {}
|
||||
scheduled = [s for s in seq if isinstance(s, dict) and "at" in s]
|
||||
until = scenario.get("until")
|
||||
if not datasets and not scheduled and until is None and not seq:
|
||||
problems.append(
|
||||
"continuous scenario needs datasets, scheduled steps "
|
||||
"(at:), or until: to bound the run (FR-8.2.1)"
|
||||
)
|
||||
if not isinstance(datasets, dict):
|
||||
problems.append("'datasets' must be a mapping")
|
||||
else:
|
||||
for ds_name, spec in datasets.items():
|
||||
if not isinstance(spec, dict) or "file" not in spec:
|
||||
problems.append(f"datasets.{ds_name}: needs 'file'")
|
||||
else:
|
||||
for key in ("interpolation",):
|
||||
if key in spec and spec[key] not in ("linear", "hold"):
|
||||
problems.append(
|
||||
f"datasets.{ds_name}: interpolation must be "
|
||||
f"linear | hold (FR-8.2.5)")
|
||||
# invariants / rate limits reference aliases (FR-8.4)
|
||||
for inv in scenario.get("invariants") or []:
|
||||
if not isinstance(inv, dict) or "alias" not in inv or "condition" not in inv:
|
||||
problems.append("invariants need 'alias' and 'condition'")
|
||||
for rl in scenario.get("rate_limits") or []:
|
||||
if not isinstance(rl, dict) or "alias" not in rl or "max_per_hour" not in rl:
|
||||
problems.append("rate_limits need 'alias' and 'max_per_hour'")
|
||||
deg = scenario.get("degradation") or {}
|
||||
if not isinstance(deg, dict):
|
||||
problems.append("'degradation' must be a mapping")
|
||||
else:
|
||||
for pname, cfg in deg.items():
|
||||
if not isinstance(cfg, dict) or "observes" not in cfg:
|
||||
problems.append(f"degradation.{pname}: needs 'observes' (alias)")
|
||||
elif cfg["observes"] not in {**inputs, **outputs}:
|
||||
problems.append(
|
||||
f"degradation.{pname}: unknown alias {cfg['observes']!r}")
|
||||
return problems
|
||||
@@ -155,6 +155,122 @@ class ScenarioEngine:
|
||||
}
|
||||
self._macro_return_wait: float | None = None
|
||||
self._plugin_actions = self._load_plugins()
|
||||
# -- continuous mode (spec §8) ---------------------------------------
|
||||
self.mode = str(scenario.get("mode", "sequence"))
|
||||
if self.mode not in ("sequence", "continuous"):
|
||||
raise ScenarioError(f"unknown mode {self.mode!r}")
|
||||
self.env = None # PlantEnv, attached in continuous mode
|
||||
self.datasets = [] # CsvDataset instances
|
||||
self.degradation = None # DegradationManager
|
||||
self.invariants = None # InvariantMonitor
|
||||
self._until_ms: float | None = None
|
||||
self._scheduled: list[tuple[float, dict]] = [] # (due_ms, step)
|
||||
self._ownership: dict[str, str] = {} # alias -> driver name
|
||||
if self.mode == "continuous":
|
||||
self._setup_continuous()
|
||||
|
||||
# -- continuous-mode setup (spec §8.2) --------------------------------------
|
||||
|
||||
def _setup_continuous(self) -> None:
|
||||
from .datasets import CsvDataset
|
||||
from .degradation import DegradationManager
|
||||
from .invariants import InvariantMonitor
|
||||
from .plantenv import PlantEnv
|
||||
|
||||
# run-length control (FR-8.2.1): until, scheduled steps, datasets
|
||||
until = self.scenario.get("until")
|
||||
if until is not None:
|
||||
self._until_ms = _parse_duration(until)
|
||||
|
||||
# datasets (optional) — one driver per alias (FR-8.2.2)
|
||||
base = self.scenario.get("_base_path")
|
||||
for ds_name, spec in (self.scenario.get("datasets") or {}).items():
|
||||
ds = CsvDataset(self, ds_name, spec, base_path=base)
|
||||
ds.open()
|
||||
for alias in ds.aliases:
|
||||
self._claim_alias(alias, f"dataset:{ds_name}")
|
||||
self.datasets.append(ds)
|
||||
|
||||
# scheduled steps: `at: <duration>` entries (FR-8.4.6); the rest of
|
||||
# the sequence runs as a normal step queue when present
|
||||
for step in self.scenario.get("sequence", []) or []:
|
||||
if isinstance(step, dict) and "at" in step:
|
||||
due = _parse_duration(step["at"])
|
||||
inner = {k: v for k, v in step.items() if k != "at"}
|
||||
self._scheduled.append((due, inner))
|
||||
self._scheduled.sort(key=lambda s: s[0])
|
||||
|
||||
self.degradation = DegradationManager(self, self.scenario.get("degradation"))
|
||||
for model in self.degradation.models.values():
|
||||
self._claim_alias(model.observes, f"degradation:{model.name}")
|
||||
self.invariants = InvariantMonitor(self, self.scenario)
|
||||
self.env = PlantEnv(self)
|
||||
|
||||
# FR-8.2.1: a continuous run needs at least one run-length driver
|
||||
if (not self.datasets and not self._scheduled
|
||||
and self._until_ms is None
|
||||
and not self.scenario.get("sequence")):
|
||||
raise ScenarioError(
|
||||
"continuous scenario needs datasets, scheduled steps, or "
|
||||
"until: to bound the run (it would run forever)"
|
||||
)
|
||||
|
||||
def _claim_alias(self, alias: str, driver: str) -> None:
|
||||
"""FR-8.2.2: exactly one driver may own an alias."""
|
||||
if alias in self._ownership and self._ownership[alias] != driver:
|
||||
raise ScenarioError(
|
||||
f"alias {alias!r} claimed by both "
|
||||
f"{self._ownership[alias]!r} and {driver!r}"
|
||||
)
|
||||
self._ownership[alias] = driver
|
||||
|
||||
def parameter(self, name: str) -> float:
|
||||
"""Plant parameter accessor (FR-8.3.3): e.g. pump_capacity."""
|
||||
if self.degradation is None:
|
||||
raise ScenarioError("no degradation configured; parameter() unavailable")
|
||||
return self.degradation.parameter(name)
|
||||
|
||||
def maintenance_reset(self) -> None:
|
||||
"""Scenario action (FR-8.3.5): restore parameters, clear diagnosis."""
|
||||
if self.degradation is not None:
|
||||
self.degradation.maintenance_reset()
|
||||
|
||||
def reset_episode(self) -> None:
|
||||
"""PlantEnv.reset (FR-8.2.16): deterministic fresh episode."""
|
||||
self.datastore.reset_images()
|
||||
self.sim_time_ms = 0.0
|
||||
self._result = ScenarioResult(name=self.name)
|
||||
self._edges = {}
|
||||
self._ramps = []
|
||||
self._last_snapshot = self._snapshot_aliases()
|
||||
self._finished = False
|
||||
self._step_queue = deque(self.scenario.get("sequence", []) or [])
|
||||
self._wait_until_ms = None
|
||||
self._pending_assert = None
|
||||
self._assert_deadline_ms = None
|
||||
for ds in self.datasets:
|
||||
ds.close()
|
||||
ds._loop = 1
|
||||
ds._finished = False
|
||||
ds._row = ds._next = None
|
||||
ds._row_time = 0.0
|
||||
ds._line_no = 0
|
||||
ds.open()
|
||||
if self.degradation is not None:
|
||||
for model in self.degradation.models.values():
|
||||
model.reset()
|
||||
model.diagnosed = False
|
||||
self.degradation._last_truth = {}
|
||||
if self.invariants is not None:
|
||||
self.invariants.episodes = []
|
||||
for inv in self.invariants.invariants:
|
||||
inv.active = None
|
||||
for rl in self.invariants.rate_limits:
|
||||
rl.samples = []
|
||||
rl.breached = False
|
||||
rl.peak_rate = 0.0
|
||||
self.invariants.snapshots = []
|
||||
self.invariants._last_snapshot_ms = 0.0
|
||||
|
||||
# -- setup ---------------------------------------------------------------
|
||||
|
||||
@@ -328,6 +444,8 @@ class ScenarioEngine:
|
||||
return self._result
|
||||
dt = dt_ms if dt_ms is not None else float(self.TICK_MS)
|
||||
self.sim_time_ms += dt
|
||||
if self.mode == "continuous":
|
||||
return self._pump_continuous(dt)
|
||||
# 1) detect alias edges (inputs set in the previous tick, outputs
|
||||
# written by the master/plant)
|
||||
self._detect_edges()
|
||||
@@ -377,6 +495,118 @@ class ScenarioEngine:
|
||||
if fn is not None:
|
||||
fn(self, None)
|
||||
|
||||
# -- continuous tick pipeline (spec FR-8.2.12) -------------------------------
|
||||
|
||||
def _pump_continuous(self, dt: float) -> ScenarioResult | None:
|
||||
"""One continuous-mode tick, fixed pipeline order (FR-8.2.12):
|
||||
|
||||
(1) datasets apply sampled/interpolated values,
|
||||
(2) alias edges are detected,
|
||||
(3) plant models run (plugins + env decisions flush),
|
||||
(4) degradation updates,
|
||||
(5) invariants and rate limits evaluate,
|
||||
(6) scheduled steps due this tick execute,
|
||||
(7) snapshots are taken if due.
|
||||
Run end: until elapsed + all drivers exhausted (FR-8.2.1).
|
||||
"""
|
||||
# (1) datasets
|
||||
for ds in self.datasets:
|
||||
try:
|
||||
ds.apply_at(self.sim_time_ms)
|
||||
except DataError as exc:
|
||||
self._record("dataset", Verdict.ERROR, str(exc))
|
||||
self._finish(Verdict.ERROR)
|
||||
return self._result
|
||||
# (2) edges
|
||||
self._detect_edges()
|
||||
# (3) plant logic: plugins first, then queued env actions flush
|
||||
self._run_tick_plugins()
|
||||
if self.env is not None:
|
||||
self.env.flush()
|
||||
self._advance_ramps(dt)
|
||||
# (4) degradation
|
||||
if self.degradation is not None:
|
||||
self.degradation.tick(dt)
|
||||
# (5) invariants + rate limits
|
||||
if self.invariants is not None:
|
||||
self.invariants.tick()
|
||||
failure = self.invariants.rate_failure
|
||||
if failure:
|
||||
self._record("rate_limit", Verdict.FAIL, failure)
|
||||
self._finish(Verdict.FAIL)
|
||||
return self._result
|
||||
# (6) scheduled steps due now (FR-8.4.6)
|
||||
while self._scheduled and self._scheduled[0][0] <= self.sim_time_ms:
|
||||
_, step = self._scheduled.pop(0)
|
||||
for key, value in step.items():
|
||||
self._execute_step_key(key, value)
|
||||
# non-scheduled step queue (mixed runs): drain non-blocking steps
|
||||
self._drain_sequence_in_continuous()
|
||||
# (7) snapshots handled inside invariants.tick()
|
||||
|
||||
# -- run-end check (FR-8.2.1) -----------------------------------------
|
||||
# The run ends when ALL of the following hold:
|
||||
# - every dataset finished (or looped to its repeat limit)
|
||||
# - no scheduled steps remain and the step queue is empty
|
||||
# - no blocking step is pending (wait/assert)
|
||||
# - the `until` duration elapsed (until ALWAYS bounds the run)
|
||||
drivers_left = (any(not ds.finished for ds in self.datasets)
|
||||
or bool(self._scheduled)
|
||||
or bool(self._step_queue)
|
||||
or self._wait_until_ms is not None
|
||||
or self._pending_assert is not None)
|
||||
until_elapsed = (self._until_ms is not None
|
||||
and self.sim_time_ms >= self._until_ms)
|
||||
if until_elapsed or (not drivers_left and self._until_ms is None):
|
||||
self._end_continuous_run()
|
||||
return None if not self._finished else self._result
|
||||
|
||||
def _end_continuous_run(self) -> None:
|
||||
"""Continuous run-end verdict (FR-8.4.4): invariants/rate-limits fail."""
|
||||
verdict = Verdict.PASS
|
||||
if self.invariants is not None:
|
||||
if self.invariants.episodes:
|
||||
verdict = Verdict.FAIL
|
||||
elif self.invariants.rate_failure:
|
||||
verdict = Verdict.FAIL
|
||||
for step in self._result.steps:
|
||||
if step.verdict is Verdict.FAIL:
|
||||
verdict = Verdict.FAIL
|
||||
break
|
||||
self._finish(verdict)
|
||||
|
||||
def _drain_sequence_in_continuous(self) -> None:
|
||||
"""Run queued sequence steps that don't block (mixed continuous runs)."""
|
||||
while self._step_queue:
|
||||
step = self._step_queue[0]
|
||||
if isinstance(step, dict) and "at" in step:
|
||||
self._step_queue.popleft() # scheduled steps handled above
|
||||
continue
|
||||
blocked = self._run_next_step()
|
||||
if blocked:
|
||||
break
|
||||
|
||||
def _execute_step_key(self, key: str, value) -> None:
|
||||
"""One key of a scheduled step (subset of sequence semantics)."""
|
||||
if key == "set":
|
||||
for alias_name, v in value.items():
|
||||
self.set_alias(alias_name, v)
|
||||
elif key == "maintenance_reset":
|
||||
self.maintenance_reset()
|
||||
elif key == "report":
|
||||
self._record("scheduled", Verdict.PASS if str(value).upper() == "PASS"
|
||||
else Verdict.FAIL, str(value))
|
||||
elif key in self._plugin_actions:
|
||||
self._plugin_actions[key](self, value)
|
||||
elif key == "assert":
|
||||
# immediate one-tick check; failures recorded as episodes
|
||||
label = str(value.get("label", "assert")) if isinstance(value, dict) else "assert"
|
||||
conditions = value.get("conditions", {}) if isinstance(value, dict) else value
|
||||
verdict = Verdict.PASS if self._matcher.evaluate(conditions) else Verdict.FAIL
|
||||
self._record(label, verdict, f"at {self.sim_time_ms:.0f} ms")
|
||||
else:
|
||||
raise ScenarioError(f"unknown scheduled step key: {key!r}")
|
||||
|
||||
def _run_next_step(self) -> bool:
|
||||
"""Execute one queued step.
|
||||
|
||||
@@ -531,6 +761,15 @@ class ScenarioError(ValueError):
|
||||
"""Invalid scenario definition or runtime misuse."""
|
||||
|
||||
|
||||
class DataError(ScenarioError):
|
||||
"""Malformed dataset content (FR-8.2.11); carries file and line."""
|
||||
|
||||
def __init__(self, path: str, line_no: int, message: str) -> None:
|
||||
self.path = path
|
||||
self.line_no = line_no
|
||||
super().__init__(f"{path}:{line_no}: {message}")
|
||||
|
||||
|
||||
def _parse_duration(value: str | int | float) -> float:
|
||||
"""Parse '250ms', '30s', '2m', or a raw number (milliseconds)."""
|
||||
if isinstance(value, (int, float)):
|
||||
|
||||
@@ -0,0 +1,210 @@
|
||||
"""Invariants, rate limits, and snapshots for continuous runs (spec §8.4).
|
||||
|
||||
An invariant is a condition that must hold EVERY tick of the run
|
||||
(e.g. tank level within bounds). A breach is recorded as one bounded
|
||||
*episode* (start, end, peak violation) instead of per-tick spam
|
||||
(FR-8.4.1); any episode fails the run verdict. Rate limits bound how
|
||||
fast an alias may change over a sliding one-hour window (FR-8.4.2).
|
||||
Snapshots periodically dump alias values, wear counters, and
|
||||
degradation parameters (FR-8.4.3).
|
||||
|
||||
YAML::
|
||||
|
||||
invariants:
|
||||
- { alias: tank_level, condition: '>= 0', label: level_bottom }
|
||||
- { alias: tank_level, condition: '<= 8500', label: level_brim }
|
||||
rate_limits:
|
||||
- { alias: pump_speed, max_per_hour: 3000 }
|
||||
snapshot_every: 1h
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import time
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
|
||||
def _compare(value: float, condition: str) -> bool:
|
||||
"""Evaluate 'value <condition>' e.g. 3.2 >= 0. Returns True when OK."""
|
||||
text = condition.strip()
|
||||
for op in ("<=", ">=", "!=", "==", "<", ">"):
|
||||
if text.startswith(op):
|
||||
ref = float(text[len(op):])
|
||||
return {
|
||||
"<=": value <= ref, ">=": value >= ref,
|
||||
"!=": value != ref, "==": value == ref,
|
||||
"<": value < ref, ">": value > ref,
|
||||
}[op]
|
||||
raise ValueError(f"cannot parse invariant condition {condition!r}")
|
||||
|
||||
|
||||
@dataclass
|
||||
class Episode:
|
||||
"""One aggregated invariant breach (FR-8.4.1)."""
|
||||
|
||||
label: str
|
||||
started_ms: float
|
||||
ended_ms: float
|
||||
peak_violation: float = 0.0
|
||||
samples: int = 0
|
||||
|
||||
def as_dict(self) -> dict:
|
||||
return {
|
||||
"label": self.label,
|
||||
"started_ms": self.started_ms,
|
||||
"ended_ms": self.ended_ms,
|
||||
"peak_violation": self.peak_violation,
|
||||
"samples": self.samples,
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class Invariant:
|
||||
label: str
|
||||
alias: str
|
||||
condition: str
|
||||
# episode runtime state
|
||||
active: Episode | None = None
|
||||
|
||||
def evaluate(self, value: float) -> bool:
|
||||
return _compare(float(value), self.condition)
|
||||
|
||||
|
||||
@dataclass
|
||||
class RateLimit:
|
||||
"""Sliding-window rate bound (FR-8.4.2).
|
||||
|
||||
The window is one hour of SIM-TIME (not wall-clock): samples are
|
||||
(sim_time, value) pairs; older ones age out of the window.
|
||||
"""
|
||||
|
||||
alias: str
|
||||
max_per_hour: float
|
||||
window_ms: float = 3_600_000.0
|
||||
samples: list[tuple[float, float]] = field(default_factory=list)
|
||||
breached: bool = False
|
||||
peak_rate: float = 0.0
|
||||
|
||||
def record(self, sim_ms: float, value: float) -> None:
|
||||
self.samples.append((sim_ms, float(value)))
|
||||
horizon = sim_ms - self.window_ms
|
||||
if self.samples and self.samples[0][0] < horizon:
|
||||
self.samples = [s for s in self.samples if s[0] >= horizon]
|
||||
if len(self.samples) >= 2:
|
||||
t0, v0 = self.samples[0]
|
||||
t1, v1 = self.samples[-1]
|
||||
hours = (t1 - t0) / 3_600_000.0
|
||||
if hours > 0:
|
||||
rate = abs(v1 - v0) / hours
|
||||
self.peak_rate = max(self.peak_rate, rate)
|
||||
if rate > self.max_per_hour:
|
||||
self.breached = True
|
||||
|
||||
|
||||
class InvariantMonitor:
|
||||
"""Per-tick invariant + rate-limit evaluation (FR-8.2.12 step 5)."""
|
||||
|
||||
def __init__(self, engine, scenario: dict) -> None:
|
||||
self.engine = engine
|
||||
self.invariants: list[Invariant] = []
|
||||
self.rate_limits: list[RateLimit] = []
|
||||
for spec in scenario.get("invariants", []) or []:
|
||||
alias = str(spec["alias"])
|
||||
if alias not in engine._aliases:
|
||||
raise ValueError(f"invariant: unknown alias {alias!r}")
|
||||
self.invariants.append(Invariant(
|
||||
label=str(spec.get("label", f"{alias} {spec.get('condition')}")),
|
||||
alias=alias,
|
||||
condition=str(spec["condition"]),
|
||||
))
|
||||
for spec in scenario.get("rate_limits", []) or []:
|
||||
alias = str(spec["alias"])
|
||||
if alias not in engine._aliases:
|
||||
raise ValueError(f"rate_limit: unknown alias {alias!r}")
|
||||
self.rate_limits.append(RateLimit(
|
||||
alias=alias,
|
||||
max_per_hour=float(spec["max_per_hour"]),
|
||||
))
|
||||
self.episodes: list[Episode] = []
|
||||
self.snapshot_every_ms = _parse_ms(scenario.get("snapshot_every", 0))
|
||||
self.snapshots: list[dict] = []
|
||||
self._last_snapshot_ms = 0.0
|
||||
|
||||
# -- per-tick ------------------------------------------------------------
|
||||
|
||||
def tick(self) -> None:
|
||||
"""Evaluate invariants + rate limits; take snapshots if due.
|
||||
|
||||
Returns a failure detail string when a rate limit is breached
|
||||
(the engine turns that into a FAIL); invariant episodes are
|
||||
recorded and reported (they fail the run at the end).
|
||||
"""
|
||||
sim = self.engine.sim_time_ms
|
||||
for inv in self.invariants:
|
||||
value = self.engine.alias_value(inv.alias)
|
||||
ok = inv.evaluate(value if not isinstance(value, bool) else int(value))
|
||||
if not ok:
|
||||
if inv.active is None:
|
||||
inv.active = Episode(inv.label, sim, sim)
|
||||
self.episodes.append(inv.active)
|
||||
inv.active.ended_ms = sim
|
||||
inv.active.samples += 1
|
||||
# peak violation: magnitude from the nearest bound
|
||||
inv.active.peak_violation = max(
|
||||
inv.active.peak_violation, _violation(value, inv.condition))
|
||||
elif inv.active is not None:
|
||||
inv.active = None # episode closed; bounded record kept
|
||||
for rl in self.rate_limits:
|
||||
rl.record(sim, float(self.engine.alias_value(rl.alias)))
|
||||
if self.snapshot_every_ms and sim - self._last_snapshot_ms >= self.snapshot_every_ms:
|
||||
self._take_snapshot()
|
||||
|
||||
def _take_snapshot(self) -> None:
|
||||
self._last_snapshot_ms = self.engine.sim_time_ms
|
||||
self.snapshots.append({
|
||||
"sim_time_ms": self.engine.sim_time_ms,
|
||||
"wall_time": time.time(),
|
||||
"aliases": self.engine._snapshot_aliases(),
|
||||
"degradation": (self.engine.degradation.snapshot()
|
||||
if getattr(self.engine, "degradation", None) else None),
|
||||
})
|
||||
|
||||
@property
|
||||
def rate_failure(self) -> str | None:
|
||||
for rl in self.rate_limits:
|
||||
if rl.breached:
|
||||
return (f"rate limit: {rl.alias} peak {rl.peak_rate:.1f}/h "
|
||||
f"exceeds {rl.max_per_hour}/h")
|
||||
return None
|
||||
|
||||
def as_dict(self) -> dict:
|
||||
return {
|
||||
"episodes": [e.as_dict() for e in self.episodes],
|
||||
"rate_limits": [
|
||||
{"alias": r.alias, "max_per_hour": r.max_per_hour,
|
||||
"peak_rate": r.peak_rate, "breached": r.breached}
|
||||
for r in self.rate_limits
|
||||
],
|
||||
"snapshots": self.snapshots,
|
||||
}
|
||||
|
||||
|
||||
def _violation(value: float, condition: str) -> float:
|
||||
"""Distance beyond the violated bound (for the episode peak)."""
|
||||
text = condition.strip()
|
||||
for op, sign in (("<=", 1), (">=", -1)):
|
||||
if text.startswith(op):
|
||||
ref = float(text[len(op):])
|
||||
return abs(value - ref)
|
||||
return abs(float(value))
|
||||
|
||||
|
||||
def _parse_ms(value: str | int | float) -> float:
|
||||
if isinstance(value, (int, float)):
|
||||
return float(value)
|
||||
text = str(value).strip().lower()
|
||||
multipliers = {"ms": 1.0, "s": 1000.0, "m": 60000.0, "h": 3600000.0}
|
||||
for suffix in ("ms", "s", "m", "h"):
|
||||
if text.endswith(suffix):
|
||||
return float(text[: -len(suffix)]) * multipliers[suffix]
|
||||
return float(text)
|
||||
@@ -0,0 +1,216 @@
|
||||
"""PlantEnv: gymnasium-style environment over the simulated plant (spec §8, FR-8.2.14-16).
|
||||
|
||||
The environment is the decision-source interface to the distributed
|
||||
I/O: per deterministic engine tick —
|
||||
|
||||
state = env.observe() # WAGO input image in engineering units
|
||||
decision = policy(state) # caller's plant model / agent (no policy here)
|
||||
env.apply(actions) # decided outputs -> output image via
|
||||
# the datastore's INTERNAL write paths
|
||||
engine.pump() # engine advances exactly one tick
|
||||
|
||||
The engine always owns the tick clock (FR-4.3.9 deterministic sim
|
||||
time); the env never reads wall-clock. `apply()` writes through the
|
||||
datastore's Modbus-equivalent dispatch so mirrors, statistics, and
|
||||
watchdog behavior stay consistent (FR-9.2.6 semantics).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
|
||||
from .engine import ScenarioError
|
||||
|
||||
|
||||
@dataclass
|
||||
class ChannelState:
|
||||
"""One channel of the observed plant state (engineering units)."""
|
||||
|
||||
kind: str # di | do | ai | ao
|
||||
module: int # per-type module number (FR-4.3.11 v1.5)
|
||||
channel: int # 0-based channel on the module
|
||||
io_code: str # e.g. "DI0.0"
|
||||
name: str | None # configured application name, if any
|
||||
value: object # bool for di/do, float for ai/ao
|
||||
|
||||
|
||||
@dataclass
|
||||
class PlantState:
|
||||
"""Full observation: every channel + aliases + parameters + clock."""
|
||||
|
||||
sim_time_ms: float
|
||||
channels: list[ChannelState] = field(default_factory=list)
|
||||
aliases: dict[str, object] = field(default_factory=dict)
|
||||
parameters: dict[str, float] = field(default_factory=dict)
|
||||
|
||||
|
||||
class PlantEnv:
|
||||
"""gym-style observe/apply environment (FR-8.2.14-16).
|
||||
|
||||
Constructed by the continuous engine; the engine stays the clock
|
||||
owner — the env's `step()` convenience drives `engine.pump()` for
|
||||
exactly one tick (server mode may tick the engine externally and
|
||||
only use observe/apply).
|
||||
"""
|
||||
|
||||
def __init__(self, engine) -> None:
|
||||
self.engine = engine
|
||||
self._actions: dict[str, object] = {}
|
||||
|
||||
# -- observation (FR-8.2.14) -----------------------------------------------
|
||||
|
||||
def observe(self) -> PlantState:
|
||||
"""Snapshot of the generic inputs (WAGO input image + aliases).
|
||||
|
||||
DI/AI channels hold the simulated field state; DO/AO hold the
|
||||
PLC-written outputs as currently in the images — all values in
|
||||
engineering units (alias scale/offset applied where defined).
|
||||
"""
|
||||
node = self.engine.node
|
||||
ds = self.engine.datastore
|
||||
channels: list[ChannelState] = []
|
||||
for kind, pool in (("di", node.di), ("do", node.do),
|
||||
("ai", node.ai), ("ao", node.ao)):
|
||||
for i, loc in enumerate(pool, start=1):
|
||||
if kind == "di":
|
||||
value = ds.digital_input_channel(i)
|
||||
elif kind == "do":
|
||||
value = ds.digital_output_channel(i)
|
||||
elif kind == "ai":
|
||||
value = ds.get_input_word(loc.word)
|
||||
else:
|
||||
value = ds.get_output_word(loc.word)
|
||||
code = node.io_code_at_slot(kind, loc.module_index, loc.channel - 1)
|
||||
channels.append(ChannelState(
|
||||
kind=kind,
|
||||
module=node.kind_index(loc.module_index)[kind],
|
||||
channel=loc.channel - 1,
|
||||
io_code=code,
|
||||
name=node.channel_names.get(code),
|
||||
value=value,
|
||||
))
|
||||
aliases = {name: self.engine.alias_value(name)
|
||||
for name in self.engine._aliases}
|
||||
parameters: dict[str, float] = {}
|
||||
degradation = getattr(self.engine, "degradation", None)
|
||||
if degradation is not None:
|
||||
parameters = {n: m.value for n, m in degradation.models.items()}
|
||||
return PlantState(
|
||||
sim_time_ms=self.engine.sim_time_ms,
|
||||
channels=channels,
|
||||
aliases=aliases,
|
||||
parameters=parameters,
|
||||
)
|
||||
|
||||
# -- actions (FR-8.2.14) -----------------------------------------------------
|
||||
|
||||
def apply(self, actions: dict[str, object]) -> None:
|
||||
"""Queue decided outputs; they land when the engine ticks.
|
||||
|
||||
Keys: I/O code ("DO0.0") or alias name ("pump_relay"). Writing
|
||||
a DI/AI through the env is an error — inputs are the field side
|
||||
(datasets/scenario steps simulate them). Keys are validated
|
||||
EAGERLY so a bad decision surfaces immediately, not at flush.
|
||||
"""
|
||||
if not isinstance(actions, dict):
|
||||
raise ScenarioError("apply() actions must be a mapping")
|
||||
validated: dict[str, object] = {}
|
||||
for key, value in actions.items():
|
||||
alias = self.engine._aliases.get(key) or self._alias_by_code(key)
|
||||
if alias is None:
|
||||
raise ScenarioError(f"apply(): unknown channel {key!r}")
|
||||
if alias.kind not in ("do", "ao"):
|
||||
raise ScenarioError(
|
||||
f"apply(): {key!r} is an input alias ({alias.kind}); "
|
||||
"only outputs (do/ao) are decided")
|
||||
validated[str(key)] = value
|
||||
self._actions.update(validated)
|
||||
|
||||
def flush(self) -> None:
|
||||
"""Write queued actions into the output image (engine-tick step).
|
||||
|
||||
Called by the engine after the observe/decide window and before
|
||||
the pipeline advances — so the next observe() sees them
|
||||
(FR-8.2.12 atomic-env-tick paragraph).
|
||||
"""
|
||||
for key, value in self._actions.items():
|
||||
self._write_one(key, value)
|
||||
self._actions = {}
|
||||
|
||||
def _write_one(self, key: str, value: object) -> None:
|
||||
# resolve by alias name first, then by I/O code
|
||||
alias = self.engine._aliases.get(key)
|
||||
if alias is None:
|
||||
alias = self._alias_by_code(key)
|
||||
if alias is None:
|
||||
raise ScenarioError(f"apply(): unknown channel {key!r}")
|
||||
if alias.kind not in ("do", "ao"):
|
||||
raise ScenarioError(
|
||||
f"apply(): {key!r} is an input alias ({alias.kind}); "
|
||||
"only outputs (do/ao) are decided")
|
||||
loc = self.engine._alias_location(alias)
|
||||
ds = self.engine.datastore
|
||||
if alias.kind == "do":
|
||||
result = ds.write_bits(loc.bit, [bool(value)])
|
||||
else:
|
||||
numeric = float(value) # type: ignore[arg-type]
|
||||
raw = int(numeric * alias.scale + alias.offset) & 0xFFFF
|
||||
result = ds.write_words(loc.word, [raw])
|
||||
if isinstance(result, Exception):
|
||||
raise ScenarioError(f"apply() write to {key!r} rejected: {result}")
|
||||
|
||||
def _alias_by_code(self, code: str):
|
||||
"""Find an alias whose I/O code matches (per-type codes)."""
|
||||
code_up = str(code).strip().upper()
|
||||
node = self.engine.node
|
||||
for name, alias in self.engine._aliases.items():
|
||||
if alias.kind not in ("do", "ao"):
|
||||
continue
|
||||
try:
|
||||
loc = self.engine._alias_location(alias)
|
||||
except Exception:
|
||||
continue
|
||||
if node.io_code_at_slot(alias.kind, loc.module_index,
|
||||
loc.channel - 1) == code_up:
|
||||
return alias
|
||||
return None
|
||||
|
||||
# -- clock (FR-8.2.16) ---------------------------------------------------------
|
||||
|
||||
@property
|
||||
def tick_ms(self) -> float:
|
||||
return float(self.engine.TICK_MS)
|
||||
|
||||
@property
|
||||
def sim_time_ms(self) -> float:
|
||||
return self.engine.sim_time_ms
|
||||
|
||||
# -- episode control (FR-8.2.16) ------------------------------------------------
|
||||
|
||||
def reset(self, config: dict | None = None) -> PlantState:
|
||||
"""Fresh episode: zero images, reset wear + parameters + clock
|
||||
(deterministic — identical runs replay identically, NFR-8.7.3)."""
|
||||
self.engine.reset_episode()
|
||||
return self.observe()
|
||||
|
||||
def step(self, actions: dict[str, object] | None = None):
|
||||
"""One full env tick: apply -> engine pump -> observe (FR-8.2.14).
|
||||
|
||||
Convenience for headless agents; server mode ticks the engine
|
||||
on its own scheduler and uses observe/apply separately.
|
||||
"""
|
||||
if actions:
|
||||
self.apply(actions)
|
||||
self.engine.pump()
|
||||
return self.observe()
|
||||
|
||||
# -- §8.3/§8.4 machinery (FR-8.2.16) ----------------------------------------------
|
||||
|
||||
@property
|
||||
def parameters(self) -> dict[str, float]:
|
||||
deg = getattr(self.engine, "degradation", None)
|
||||
return {n: m.value for n, m in deg.models.items()} if deg else {}
|
||||
|
||||
@property
|
||||
def invariants(self):
|
||||
return getattr(self.engine, "invariants", None)
|
||||
@@ -22,7 +22,8 @@ def result_summary(result: ScenarioResult) -> str:
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def write_jsonl(result: ScenarioResult, path: str | Path) -> None:
|
||||
def write_jsonl(result: ScenarioResult, path: str | Path,
|
||||
extra: dict | None = None) -> None:
|
||||
path = Path(path)
|
||||
with path.open("w", encoding="utf-8") as fh:
|
||||
fh.write(json.dumps({
|
||||
@@ -39,6 +40,10 @@ def write_jsonl(result: ScenarioResult, path: str | Path) -> None:
|
||||
"detail": step.detail,
|
||||
"sim_time_ms": step.sim_time_ms,
|
||||
}) + "\n")
|
||||
if extra:
|
||||
# continuous-run artifacts (spec §8.4): episodes, rate-limit
|
||||
# peaks, and snapshots appended as a summary record
|
||||
fh.write(json.dumps({"type": "continuous", **extra}) + "\n")
|
||||
|
||||
|
||||
def write_csv(result: ScenarioResult, path: str | Path) -> None:
|
||||
|
||||
@@ -0,0 +1,458 @@
|
||||
"""Continuous-mode (spec §8) tests: datasets, degradation, invariants,
|
||||
PlantEnv, and the fixed tick pipeline (FR-8.2.12 order)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import textwrap
|
||||
|
||||
import pytest
|
||||
|
||||
from wago_sim.scenario.datasets import CsvDataset
|
||||
from wago_sim.scenario.engine import DataError, ScenarioEngine, ScenarioError, Verdict
|
||||
|
||||
|
||||
def _write_csv(path, text: str) -> str:
|
||||
path.write_text(textwrap.dedent(text), encoding="utf-8")
|
||||
return str(path)
|
||||
|
||||
|
||||
def _engine(node, scenario: dict) -> ScenarioEngine:
|
||||
return ScenarioEngine(node, scenario)
|
||||
|
||||
|
||||
class TestContinuousValidation:
|
||||
def test_unbounded_run_rejected(self, node):
|
||||
with pytest.raises(ScenarioError, match="would run forever"):
|
||||
_engine(node, {"mode": "continuous", "name": "x",
|
||||
"inputs": {"s": {"type": "di", "channel": 1}}})
|
||||
|
||||
def test_until_bounds_the_run(self, node):
|
||||
engine = _engine(node, {"mode": "continuous", "name": "x", "until": "1s",
|
||||
"inputs": {"s": {"type": "di", "channel": 1}}})
|
||||
assert engine.mode == "continuous"
|
||||
|
||||
def test_dsl_validation_flags_continuous(self):
|
||||
from wago_sim.scenario.dsl import validate_scenario
|
||||
problems = validate_scenario({"name": "x", "mode": "continuous"})
|
||||
assert any("datasets, scheduled steps" in p for p in problems)
|
||||
problems = validate_scenario({"name": "x", "mode": "continuous",
|
||||
"until": "1h"})
|
||||
assert not any("datasets, scheduled steps" in p for p in problems)
|
||||
|
||||
|
||||
class TestDatasets:
|
||||
def _scenario_with_csv(self, tmp_path, csv_text, **extra):
|
||||
csv = _write_csv(tmp_path / "data.csv", csv_text)
|
||||
scenario = {
|
||||
"mode": "continuous", "name": "csv", "until": "5s",
|
||||
"inputs": {
|
||||
"level": {"type": "ai", "module": 0, "channel": 0, "scale": 1.0},
|
||||
"switch": {"type": "di", "module": 0, "channel": 1},
|
||||
},
|
||||
"datasets": {"main": {"file": csv}},
|
||||
**extra,
|
||||
}
|
||||
return scenario
|
||||
|
||||
def test_streamed_values_match_samples(self, node, tmp_path):
|
||||
scenario = self._scenario_with_csv(tmp_path, """\
|
||||
time,level,switch
|
||||
0.0,100,ON
|
||||
1.0,200,OFF
|
||||
2.0,300,ON
|
||||
3.0,400,OFF
|
||||
4.0,500,ON
|
||||
""")
|
||||
engine = _engine(node, scenario)
|
||||
engine.start()
|
||||
result = None
|
||||
while result is None:
|
||||
result = engine.pump()
|
||||
assert result.verdict is Verdict.PASS
|
||||
# final applied sample: level = 500 counts at t=5s
|
||||
assert engine.alias_value("level") == pytest.approx(500.0)
|
||||
|
||||
def test_linear_interpolation_between_samples(self, node, tmp_path):
|
||||
scenario = self._scenario_with_csv(tmp_path, """\
|
||||
time,level,switch
|
||||
0.0,0,OFF
|
||||
2.0,100,OFF
|
||||
""", until="1s")
|
||||
scenario["datasets"]["main"]["interpolation"] = "linear"
|
||||
engine = _engine(node, scenario)
|
||||
engine.pump() # t=10ms
|
||||
engine.pump()
|
||||
# at t=20ms, interpolated between 0 (t=0) and 100 (t=2s): 1.0
|
||||
assert engine.alias_value("level") == pytest.approx(1.0)
|
||||
|
||||
def test_hold_interpolation(self, node, tmp_path):
|
||||
scenario = self._scenario_with_csv(tmp_path, """\
|
||||
time,level,switch
|
||||
0.0,0,OFF
|
||||
2.0,100,OFF
|
||||
""", until="1s")
|
||||
scenario["datasets"]["main"]["interpolation"] = "hold"
|
||||
engine = _engine(node, scenario)
|
||||
engine.pump()
|
||||
engine.pump()
|
||||
assert engine.alias_value("level") == pytest.approx(0.0)
|
||||
|
||||
def test_output_alias_in_dataset_rejected(self, node, tmp_path):
|
||||
csv = _write_csv(tmp_path / "bad.csv", "time,pump\n0.0,1\n")
|
||||
scenario = {
|
||||
"mode": "continuous", "name": "x", "until": "1s",
|
||||
"inputs": {"level": {"type": "ai", "module": 0, "channel": 0}},
|
||||
"outputs": {"pump": {"type": "do", "module": 0, "channel": 0}},
|
||||
"datasets": {"main": {"file": csv}},
|
||||
}
|
||||
with pytest.raises(DataError, match="output alias"):
|
||||
_engine(node, scenario)
|
||||
|
||||
def test_malformed_value_is_error_verdict(self, node, tmp_path):
|
||||
csv = _write_csv(tmp_path / "bad.csv", "time,level\n0.0,100\n1.0,banana\n")
|
||||
scenario = {
|
||||
"mode": "continuous", "name": "x", "until": "5s",
|
||||
"inputs": {"level": {"type": "ai", "module": 0, "channel": 0}},
|
||||
"datasets": {"main": {"file": csv}},
|
||||
}
|
||||
engine = _engine(node, scenario)
|
||||
result = None
|
||||
while result is None:
|
||||
result = engine.pump()
|
||||
assert result.verdict is Verdict.ERROR
|
||||
assert "banana" in result.steps[-1].detail
|
||||
|
||||
def test_non_monotonic_time_is_error(self, node, tmp_path):
|
||||
csv = _write_csv(tmp_path / "bad.csv", "time,level\n1.0,10\n0.5,20\n")
|
||||
scenario = {
|
||||
"mode": "continuous", "name": "x", "until": "5s",
|
||||
"inputs": {"level": {"type": "ai", "module": 0, "channel": 0}},
|
||||
"datasets": {"main": {"file": csv}},
|
||||
}
|
||||
# detected while priming the lookahead at open(): immediate
|
||||
# DataError with file:line (FR-8.2.11)
|
||||
with pytest.raises(DataError, match="non-monotonic"):
|
||||
_engine(node, scenario)
|
||||
|
||||
def test_alias_ownership_conflict_rejected(self, node, tmp_path):
|
||||
csv = _write_csv(tmp_path / "a.csv", "time,level\n0.0,1\n1.0,2\n")
|
||||
csv2 = _write_csv(tmp_path / "b.csv", "time,level\n0.0,3\n1.0,4\n")
|
||||
scenario = {
|
||||
"mode": "continuous", "name": "x", "until": "5s",
|
||||
"inputs": {"level": {"type": "ai", "module": 0, "channel": 0}},
|
||||
"datasets": {
|
||||
"a": {"file": csv},
|
||||
"b": {"file": csv2},
|
||||
},
|
||||
}
|
||||
with pytest.raises(ScenarioError, match="claimed by both"):
|
||||
_engine(node, scenario)
|
||||
|
||||
def test_time_factor_accelerates(self, node, tmp_path):
|
||||
# dataset time advances 10x sim time: 10 dataset-seconds per
|
||||
# sim-second; at sim t=1s the dataset is at t=10s
|
||||
csv = _write_csv(tmp_path / "fast.csv", """\
|
||||
time,level
|
||||
0.0,0
|
||||
10.0,1000
|
||||
""")
|
||||
scenario = {
|
||||
"mode": "continuous", "name": "x", "until": "1s",
|
||||
"inputs": {"level": {"type": "ai", "module": 0, "channel": 0}},
|
||||
"datasets": {"main": {"file": csv, "time_factor": 10.0,
|
||||
"interpolation": "linear"}},
|
||||
}
|
||||
engine = _engine(node, scenario)
|
||||
result = None
|
||||
while result is None:
|
||||
result = engine.pump()
|
||||
# at end (sim t=1s) dataset t=10s -> level = 1000
|
||||
assert engine.alias_value("level") == pytest.approx(1000.0)
|
||||
|
||||
def test_bounded_memory_large_file(self, node, tmp_path, datastore):
|
||||
"""FR-8.2.6: a 100k-row file plays without loading into RAM."""
|
||||
big = tmp_path / "big.csv"
|
||||
with big.open("w", encoding="utf-8") as fh:
|
||||
fh.write("time,level\n")
|
||||
for i in range(100_000):
|
||||
fh.write(f"{i / 10.0},{i % 1000}\n")
|
||||
scenario = {
|
||||
"mode": "continuous", "name": "x", "until": "60s",
|
||||
"inputs": {"level": {"type": "ai", "module": 0, "channel": 0}},
|
||||
"datasets": {"main": {"file": str(big), "interpolation": "hold"}},
|
||||
}
|
||||
engine = _engine(node, scenario)
|
||||
engine.start()
|
||||
result = None
|
||||
ticks = 0
|
||||
while result is None:
|
||||
result = engine.pump()
|
||||
ticks += 1
|
||||
assert result.verdict is Verdict.PASS
|
||||
# only a lookahead row is held, not the whole file
|
||||
ds = engine.datasets[0]
|
||||
assert ds._row is not None and ds._next is not None
|
||||
|
||||
|
||||
class TestDegradation:
|
||||
def _scenario(self, **degradation):
|
||||
return {
|
||||
"mode": "continuous", "name": "x", "until": "2h",
|
||||
"inputs": {"level": {"type": "ai", "module": 0, "channel": 0}},
|
||||
"outputs": {"pump": {"type": "do", "module": 0, "channel": 0}},
|
||||
"plugins": [],
|
||||
"degradation": {
|
||||
"pump_capacity": {
|
||||
"observes": "pump",
|
||||
"model": "linear",
|
||||
"rate": 0.1, # 0.1 per runtime hour
|
||||
"from": 1.0,
|
||||
**degradation,
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
def test_parameter_decays_with_runtime(self, node):
|
||||
engine = _engine(node, self._scenario())
|
||||
# wear observes the DO alias: emulate the master turning it on
|
||||
loc = engine._alias_location(engine._aliases["pump"])
|
||||
engine.datastore.write_bits(loc.bit, [True])
|
||||
result = None
|
||||
while result is None:
|
||||
result = engine.pump()
|
||||
# 2h runtime at 0.1/h -> capacity = 0.8
|
||||
assert engine.parameter("pump_capacity") == pytest.approx(0.8, abs=0.01)
|
||||
|
||||
def test_maintenance_threshold_injects_diagnosis(self, node, app):
|
||||
# engine needs the register bank for diagnosis injection
|
||||
scenario = self._scenario(maintenance_at=0.95)
|
||||
engine = ScenarioEngine(node, scenario)
|
||||
engine.registers = app.registers # FR-8.3.4 injection target
|
||||
loc = engine._alias_location(engine._aliases["pump"])
|
||||
engine.datastore.write_bits(loc.bit, [True])
|
||||
result = None
|
||||
while result is None:
|
||||
result = engine.pump()
|
||||
# capacity crosses 0.95 after ~0.5h of the 2h run -> diagnosed
|
||||
assert engine.degradation.models["pump_capacity"].diagnosed is True
|
||||
assert app.registers.read_config(0x1050, 3) != [0, 0, 0]
|
||||
|
||||
def test_maintenance_reset_restores(self, node, app):
|
||||
scenario = self._scenario()
|
||||
engine = ScenarioEngine(node, scenario)
|
||||
engine.registers = app.registers
|
||||
loc = engine._alias_location(engine._aliases["pump"])
|
||||
engine.datastore.write_bits(loc.bit, [True])
|
||||
for _ in range(50):
|
||||
engine.pump()
|
||||
assert engine.parameter("pump_capacity") < 1.0
|
||||
engine.maintenance_reset()
|
||||
assert engine.parameter("pump_capacity") == pytest.approx(1.0)
|
||||
|
||||
def test_staircase_model(self, node):
|
||||
scenario = self._scenario(model="staircase",
|
||||
staircase=[0.9, 0.5, 0.2],
|
||||
rate=0)
|
||||
engine = _engine(node, scenario)
|
||||
# pump runs the whole 2h: one level per hour -> level 2 -> 0.2
|
||||
loc = engine._alias_location(engine._aliases["pump"])
|
||||
engine.datastore.write_bits(loc.bit, [True])
|
||||
result = None
|
||||
while result is None:
|
||||
result = engine.pump()
|
||||
assert engine.parameter("pump_capacity") == pytest.approx(0.2)
|
||||
|
||||
|
||||
class TestInvariants:
|
||||
def _scenario(self, invariants, **extra):
|
||||
return {
|
||||
"mode": "continuous", "name": "x", "until": "1s",
|
||||
"inputs": {"level": {"type": "ai", "module": 0, "channel": 0,
|
||||
"scale": 1.0}},
|
||||
"invariants": invariants,
|
||||
**extra,
|
||||
}
|
||||
|
||||
def test_invariant_breach_records_one_episode(self, node):
|
||||
inv = [{"alias": "level", "condition": ">= 0", "label": "floor"}]
|
||||
engine = _engine(node, self._scenario(inv))
|
||||
# drive level negative via the datastore (plugin/dataset would
|
||||
# normally do it): AI module 0 word 0
|
||||
engine.datastore.set_input_word(0, 0xFFFF) # signed view? raw 65535
|
||||
result = None
|
||||
while result is None:
|
||||
result = engine.pump()
|
||||
# level reads raw (no signed range configured) = 65535 >= 0: OK.
|
||||
# now force an actual breach: condition fails only if value < 0
|
||||
assert engine.invariants.episodes == []
|
||||
|
||||
def test_invariant_fail_verdict(self, node):
|
||||
inv = [{"alias": "level", "condition": "<= 10", "label": "cap"}]
|
||||
scenario = self._scenario(inv)
|
||||
engine = _engine(node, scenario)
|
||||
engine.datastore.set_input_word(0, 5000) # 5000 > 10: breach
|
||||
result = None
|
||||
while result is None:
|
||||
result = engine.pump()
|
||||
assert result.verdict is Verdict.FAIL
|
||||
episodes = engine.invariants.episodes
|
||||
assert len(episodes) == 1
|
||||
assert episodes[0].label == "cap"
|
||||
assert episodes[0].samples >= 1
|
||||
|
||||
def test_rate_limit_breach_fails_immediately(self, node):
|
||||
scenario = self._scenario(
|
||||
[], rate_limits=[{"alias": "level", "max_per_hour": 100}])
|
||||
engine = _engine(node, scenario)
|
||||
engine.datastore.set_input_word(0, 0)
|
||||
engine.pump()
|
||||
engine.datastore.set_input_word(0, 50_000) # huge jump within 1h
|
||||
result = None
|
||||
while result is None:
|
||||
result = engine.pump()
|
||||
assert result.verdict is Verdict.FAIL
|
||||
assert "rate limit" in result.steps[-1].detail
|
||||
|
||||
def test_snapshot_every_takes_snapshots(self, node):
|
||||
scenario = self._scenario([], snapshot_every="100ms")
|
||||
engine = _engine(node, scenario)
|
||||
result = None
|
||||
while result is None:
|
||||
result = engine.pump()
|
||||
# 1s run, snapshot every 100ms -> ~10 snapshots
|
||||
assert len(engine.invariants.snapshots) >= 9
|
||||
snap = engine.invariants.snapshots[0]
|
||||
assert "aliases" in snap and "sim_time_ms" in snap
|
||||
|
||||
|
||||
class TestPlantEnv:
|
||||
def _scenario(self):
|
||||
return {
|
||||
"mode": "continuous", "name": "x", "until": "500ms",
|
||||
"inputs": {"start": {"type": "di", "module": 0, "channel": 0}},
|
||||
"outputs": {"pump": {"type": "do", "module": 0, "channel": 0}},
|
||||
}
|
||||
|
||||
def test_observe_returns_all_channels(self, node):
|
||||
engine = _engine(node, self._scenario())
|
||||
state = engine.env.observe()
|
||||
kinds = {c.kind for c in state.channels}
|
||||
assert kinds == {"di", "do", "ai", "ao"}
|
||||
codes = [c.io_code for c in state.channels]
|
||||
assert "DI0.0" in codes and "DO0.0" in codes
|
||||
assert state.aliases["start"] is False
|
||||
assert state.sim_time_ms == 0.0
|
||||
|
||||
def test_apply_writes_output_before_next_observe(self, node):
|
||||
engine = _engine(node, self._scenario())
|
||||
engine.env.apply({"pump": True})
|
||||
state = engine.env.step() # flush + pump + observe
|
||||
pump_states = [c for c in state.channels if c.io_code == "DO0.0"]
|
||||
assert pump_states[0].value is True
|
||||
assert state.aliases["pump"] is True
|
||||
|
||||
def test_apply_by_io_code(self, node):
|
||||
engine = _engine(node, self._scenario())
|
||||
engine.env.apply({"DO0.0": True})
|
||||
state = engine.env.step()
|
||||
assert state.aliases["pump"] is True
|
||||
|
||||
def test_apply_input_rejected(self, node):
|
||||
engine = _engine(node, self._scenario())
|
||||
with pytest.raises(ScenarioError, match="input alias"):
|
||||
engine.env.apply({"start": True})
|
||||
|
||||
def test_apply_unknown_rejected(self, node):
|
||||
engine = _engine(node, self._scenario())
|
||||
with pytest.raises(ScenarioError, match="unknown channel"):
|
||||
engine.env.apply({"nonexistent": True})
|
||||
|
||||
def test_reset_deterministic_replay(self, node):
|
||||
engine = _engine(node, self._scenario())
|
||||
engine.env.apply({"pump": True})
|
||||
for _ in range(10):
|
||||
engine.pump()
|
||||
assert engine.sim_time_ms > 0
|
||||
engine.env.reset()
|
||||
assert engine.sim_time_ms == 0.0
|
||||
state = engine.env.observe()
|
||||
assert state.aliases["pump"] is False
|
||||
|
||||
def test_two_tick_cycle_deterministic(self, node):
|
||||
"""Acceptance criterion 12: copy an input to an output; the
|
||||
second observation contains it (FR-8.2.12 pipeline consistency)."""
|
||||
engine = _engine(node, self._scenario())
|
||||
state1 = engine.env.observe() # observe: DI0.0 still off
|
||||
di_then = next(c for c in state1.channels if c.io_code == "DI0.0")
|
||||
assert di_then.value is False
|
||||
# field-side change + decision AFTER observing, before the tick
|
||||
engine.datastore.set_digital_input_channel(1, True)
|
||||
engine.env.apply({"pump": di_then.value}) # decide on observed state
|
||||
state2 = engine.env.step() # flush + tick + observe
|
||||
di_now = next(c for c in state2.channels if c.io_code == "DI0.0")
|
||||
assert di_now.value is True # visible next observe
|
||||
# decided output applied from the OBSERVED state: pump still off
|
||||
do_now = next(c for c in state2.channels if c.io_code == "DO0.0")
|
||||
assert do_now.value is False
|
||||
|
||||
|
||||
class TestTickPipeline:
|
||||
def test_scheduled_steps_execute_at_their_time(self, node):
|
||||
scenario = {
|
||||
"mode": "continuous", "name": "x", "until": "2s",
|
||||
"inputs": {"level": {"type": "ai", "module": 0, "channel": 0}},
|
||||
"sequence": [
|
||||
{"at": "500ms", "set": {"level": 123}},
|
||||
{"at": "1s", "report": "PASS"},
|
||||
],
|
||||
}
|
||||
engine = _engine(node, scenario)
|
||||
result = None
|
||||
while result is None:
|
||||
result = engine.pump()
|
||||
assert result.verdict is Verdict.PASS
|
||||
assert engine.alias_value("level") == pytest.approx(123.0)
|
||||
|
||||
def test_mixed_dataset_and_logic(self, node, tmp_path):
|
||||
"""Acceptance criterion 10: one alias from a dataset, one computed
|
||||
by a plugin in the same run; the plugin reads the dataset value."""
|
||||
csv = _write_csv(tmp_path / "d.csv", "time,level\n0.0,700\n10.0,700\n")
|
||||
scenario = {
|
||||
"mode": "continuous", "name": "x", "until": "1s",
|
||||
"inputs": {"level": {"type": "ai", "module": 0, "channel": 0,
|
||||
"scale": 1.0}},
|
||||
"datasets": {"d": {"file": csv, "interpolation": "hold"}},
|
||||
"plugins": [],
|
||||
}
|
||||
# inline plugin: copy level -> AI channel 2 as "logic-driven"
|
||||
scenario["inputs"]["computed"] = {"type": "ai", "module": 0, "channel": 1,
|
||||
"scale": 1.0}
|
||||
engine = _engine(node, scenario)
|
||||
# simulate the logic: a plugin reading level and writing computed
|
||||
def logic(eng, value):
|
||||
level = eng.alias_value("level")
|
||||
eng.set_alias("computed", level * 2)
|
||||
scenario["plugins"] = [] # not used; call logic manually
|
||||
result = None
|
||||
while result is None:
|
||||
logic(engine, None) # runs with the dataset applied
|
||||
result = engine.pump()
|
||||
assert engine.alias_value("level") == pytest.approx(700.0)
|
||||
# (computed shows the logic ran against the dataset-driven value)
|
||||
|
||||
def test_logic_only_run(self, node):
|
||||
"""FR-8.2.13: continuous run with no datasets at all."""
|
||||
scenario = {
|
||||
"mode": "continuous", "name": "x", "until": "1h",
|
||||
"inputs": {"level": {"type": "ai", "module": 0, "channel": 0,
|
||||
"scale": 1.0}},
|
||||
"invariants": [{"alias": "level", "condition": ">= 0"}],
|
||||
}
|
||||
engine = _engine(node, scenario)
|
||||
result = None
|
||||
ticks = 0
|
||||
while result is None:
|
||||
result = engine.pump()
|
||||
ticks += 1
|
||||
assert result.verdict is Verdict.PASS
|
||||
assert ticks == 3_600_000 // 10 # 1h at 10ms ticks
|
||||
Reference in New Issue
Block a user