This notebook introduces a sweep over deliveredEnergy’s own free power input, querying the relation from the model at every point and checking the sweep against HeatGenerationReq’s own 600 W threshold on HeatGenerator::power, read from the model rather than invented in Python.
Chapter 6 built HeatGenerationReq, a 600 W threshold on HeatGenerator::power, the attribute a real candidate’s power rating binds. Notebook 01 built deliveredEnergy, the energy relation this notebook now sweeps; its own power input stays free precisely so a design space can be explored independently of any one candidate’s rated value. This notebook connects the two: it sweeps deliveredEnergy’s power argument across a range, evaluates the relation at each point through the model, and marks the requirement’s own threshold on the result, instead of an energy figure invented for the plot.
from pathlib import Path
import opensysml
from toaster.report import format_diagnostics
conn = opensysml.connect(version="v0.9.0")
source = Path("../../models/ch07-cumulative.sysml").read_text()
model = conn.load_from_content(source, strict=False)
assert model.ok, f"Model failed: {format_diagnostics(model.diagnostics)}"A calc invoked without the library import its parameter types depend on fails to load. The negative control below drops the ScalarValues import Real needs.
bad_source = """
package P {
calc def Broken {
in x : Real;
return : Real = x * x;
}
}
"""
bad = conn.load_from_content(bad_source, strict=False)
assert not bad.ok, "Expected failure: Real is undefined without ScalarValues::* import"
print(f"Negative control ok: bad.ok={bad.ok}")Negative control ok: bad.ok=False
The diagnostic reports Real as unresolved: without the import, nothing declares it. HeatGenerationReq’s own 600 W threshold is real; the next cell reads it from the model instead of retyping it.
import re
from toaster.query import ApiIndex
index = ApiIndex(model)
threshold_constraint = next(
e for e in index.of_type("ConstraintUsage")
if index.qn(e.get("owner")) == "ToasterDemo::HeatGenerationReq"
)
match = re.search(r"([\d.]+)\s*\[SI::W\]", threshold_constraint["sysx:sourceText"])
power_threshold_w = float(match.group(1))
print(f"HeatGenerationReq's own threshold: {power_threshold_w} W")HeatGenerationReq's own threshold: 600.0 W
power_threshold_w comes from the requirement’s own source text in the loaded model, not a second, independently typed literal: whatever HeatGenerationReq states, this is what the sweep is checked against.
import numpy as np
duration_s = 120.0 # this chapter's own assumed operating duration, not derived from the model
rated_power = model.eval("ToasterDemo::rated.power")
print(f"Assumed duration for this sweep: {duration_s} s (not derived; this chapter's own worked example)")
print(f"rated's own power, read from the model: {rated_power}")
power_values_w = np.linspace(500.0, 1200.0, 50)
delivered_j = np.array([
model.eval(
f"ToasterDemo::rated.deliveredEnergy({p:.4f} [SI::W], {duration_s} [SI::s])"
).magnitude
for p in power_values_w
])Assumed duration for this sweep: 120.0 s (not derived; this chapter's own worked example)
rated's own power, read from the model: 800 [SI::W]
Each point on the curve is the model’s own deliveredEnergy, evaluated through model.eval at that power, not a formula rebuilt in Python: power and duration are queried, efficiency is rated’s own bound value, read automatically because the calc is invoked through rated itself. Duration is this chapter’s own assumed operating point, stated as such; nothing in Chapters 1-6 derives it.
import matplotlib.pyplot as plt
threshold_energy_j = model.eval(
f"ToasterDemo::rated.deliveredEnergy({power_threshold_w} [SI::W], {duration_s} [SI::s])"
).magnitude
power_unit = rated_power.unit.text.split("::")[-1]
energy_unit = model.eval(
f"ToasterDemo::rated.deliveredEnergy({power_threshold_w} [SI::W], {duration_s} [SI::s])"
).unit.text.split("::")[-1]
fig, ax = plt.subplots(figsize=(6, 4))
ax.plot(power_values_w, delivered_j / 1000, label="deliveredEnergy (model)")
ax.axvline(
power_threshold_w, color="red", linestyle="--",
label=f"HeatGenerationReq threshold ({power_threshold_w:.0f} {power_unit})",
)
ax.set_xlabel(f"deliveredEnergy power argument ({power_unit})")
ax.set_ylabel(f"Delivered energy (k{energy_unit})")
ax.set_title(
f"deliveredEnergy vs. power (t={duration_s:.0f} s assumed, "
f"\u03b7=rated's own bound value)"
)
ax.legend()
fig.tight_layout()
plt.show()
print(f"At the {power_threshold_w:.0f} {power_unit} threshold: {threshold_energy_j / 1000:.1f} k{energy_unit}")
print(f"At rated's own {float(rated_power.magnitude):.0f} {power_unit}: "
f"{delivered_j[np.argmin(np.abs(power_values_w - float(rated_power.magnitude)))] / 1000:.1f} k{energy_unit}")
At the 600 W threshold: 50.4 k'kg⋅m²⋅s⁻²'
At rated's own 800 W: 67.2 k'kg⋅m²⋅s⁻²'
Delivered energy from HeatGenerator::deliveredEnergy, evaluated by the model across a sweep of the calc’s own free power input, at this chapter’s own assumed duration and rated’s own bound efficiency; the vertical line marks HeatGenerationReq’s own 600 W threshold on HeatGenerator::power, read from the model. It does not derive cycle time or efficiency, and it says nothing about toast quality or user acceptance.
The threshold read from the model, the sweep computed through model.eval, and the plot rendered above are the same model, queried three different ways: nothing here is written to a file.
Try the chapter exercise in exercises/ch07/exercise.ipynb: sweep the coffee maker’s deliveredMass calc across its free throughput argument and mark BrewReq’s own threshold, read from the model.