diff --git "a/scripts/basic40_runtime_thermal.py" "b/scripts/basic40_runtime_thermal.py" new file mode 100644--- /dev/null +++ "b/scripts/basic40_runtime_thermal.py" @@ -0,0 +1,3562 @@ +"""CHEM-185 Nabertherm L 9/11/SKM: synthetic empty-furnace runtime. + +NaberthermL9Runtime is the trusted host and sole clock owner. Its direct +describe/read/invoke/write methods always use an agent identity; evaluator +access requires a separately host-registered session. This is API filtering, +not a Python-process or filesystem sandbox. No hardware/robot driver exists. +""" +from __future__ import annotations + +import argparse +import copy +import hashlib +import importlib.util +import io +import json +import math +import platform +import threading +import unittest +from datetime import datetime, timezone +from pathlib import Path + +from basic40_runtime import PROTOCOL_VERSION, SceneSynchronizationError, _number + +NABERTHERM_TYPE = "instrument.nabertherm_l9" +NABERTHERM_AMBIENT_K = 298.15 +NABERTHERM_POWER_W = 3400.0 +NABERTHERM_MAX_K = 1373.15 +NABERTHERM_REFERENCE_K = 1273.15 +NABERTHERM_REFERENCE_S = 4500.0 +NABERTHERM_LOSS_W_K = 2.0 # Assumption: one heat-up point cannot identify C and UA. +NABERTHERM_CAPACITY_J_K = -NABERTHERM_LOSS_W_K * NABERTHERM_REFERENCE_S / math.log1p( + -NABERTHERM_LOSS_W_K * (NABERTHERM_REFERENCE_K - NABERTHERM_AMBIENT_K) / NABERTHERM_POWER_W) +NABERTHERM_OPEN_LOSS_W_K = 18.0 # Additional open-door loss; unmeasured assumption. +NABERTHERM_DOOR_MAX_RAD = math.pi / 2 +NABERTHERM_SOURCE = "https://nabertherm.com/sites/default/files/2021-01/laboratory_english.pdf#page=19" +NABERTHERM_MANUAL = "https://nabertherm.com/sites/default/files/noindex/2023-01/M01.1060_English_2022-12_0.pdf" + + +def _object_schema(properties): + return {"type": "object", "properties": properties, "required": list(properties), "additionalProperties": False} + + +def _number_schema(unit, minimum=None, maximum=None): + result = {"type": "number", "x-unit": unit} + if minimum is not None: + result["minimum"] = minimum + if maximum is not None: + result["maximum"] = maximum + return result + + +def _nabertherm_slot(unit, origin, schema, visibility="agent", route=None): + return {"unit": unit, "origin": origin, "visibility": visibility, + "access": "read_write" if route else "read_only", "write_via": route, + "value_schema": schema, "sampling": {"mode": "instant", "time_domain": "simulation", "window": None}, + "reference_conditions": None} + + +def export_nabertherm_contract_metadata(): + """Type-only source of truth; no live temperatures, identities, or logs.""" + segments = {"type": "array", "minItems": 1, "maxItems": 4, + "items": _object_schema({"temperature_K": _number_schema("K", 273.15, NABERTHERM_MAX_K), + "ramp_rate_K_s": _number_schema("K/s", 0.001, 1.0), "hold_s": _number_schema("s", 0, 86400)})} + slots = { + "power.enabled": _nabertherm_slot("1", "setpoint", {"type": "boolean"}, route={"capability_id": "power.set", "parameter": "enabled"}), + "thermal.target_k": _nabertherm_slot("K", "setpoint", _number_schema("K"), route={"capability_id": "thermal.set_temperature", "parameter": "temperature_K"}), + "thermal.temperature_k": _nabertherm_slot("K", "process_truth", _number_schema("K"), "debug"), + "thermal.indicated_temperature_k": _nabertherm_slot("K", "derived", _number_schema("K")), + "door.angle_rad": _nabertherm_slot("rad", "scene", _number_schema("rad", 0, NABERTHERM_DOOR_MAX_RAD)), + "door.closed": _nabertherm_slot("1", "derived", {"type": "boolean"}), + "heater.enabled": _nabertherm_slot("1", "derived", {"type": "boolean"}), + "program.segments": _nabertherm_slot("1", "setpoint", {**segments, "minItems": 0}), + "program.running": _nabertherm_slot("1", "derived", {"type": "boolean"}), + "program.segment_index": _nabertherm_slot("1", "derived", {"type": "integer", "minimum": 0, "maximum": 4}), + "program.phase": _nabertherm_slot("1", "derived", {"type": "string", "enum": ["idle", "ramp", "hold", "paused_door", "completed", "stopped"]}), + "program.hold_elapsed_s": _nabertherm_slot("s", "derived", _number_schema("s", 0)), + } + for sid, slot in slots.items(): + slot["read_binding"] = f"NaberthermL9Session.read(instance_id=..., state_ids=['{sid}'])" + if slot["origin"] == "derived": + slot["observation_note_zh"] = "仿真派生值，quality=estimated；不是厂家实测读数。" + definitions = { + "power.set": ({"enabled": {"type": "boolean"}}, {"enabled": {"type": "boolean"}}, {"enabled": True}, "设置供电；断电停止程序并保持已发生的热状态。", ["power.enabled", "heater.enabled", "program.running", "program.phase"]), + "thermal.set_temperature": ({"temperature_K": _number_schema("K", 273.15, NABERTHERM_MAX_K)}, {"setpoint_K": _number_schema("K")}, {"temperature_K": 1273.15}, "只写温度目标；实际炉温由宿主step推进。", ["thermal.target_k"]), + "door.open": ({}, {"angle_rad": _number_schema("rad"), "closed": {"type": "boolean"}}, {}, "门绕+X向下翻90°；切断模拟加热许可并暂停程序。", ["door.angle_rad", "door.closed", "heater.enabled", "program.phase"]), + "door.close": ({}, {"angle_rad": _number_schema("rad"), "closed": {"type": "boolean"}}, {}, "关闭炉门；已供电时恢复模拟加热许可，程序继续。", ["door.angle_rad", "door.closed", "heater.enabled", "program.phase"]), + "thermal.configure_program": ({"segments": segments}, {"segment_count": {"type": "integer", "minimum": 1, "maximum": 4, "x-unit": "1"}}, {"segments": [{"temperature_K": 473.15, "ramp_rate_K_s": 0.1, "hold_s": 60}]}, "配置单个模拟温程，最多4段；每段包含目标、目标变化速率和到温后的保温时间。", ["program.segments", "program.segment_index", "program.phase", "program.hold_elapsed_s"]), + "thermal.start_program": ({}, {"running": {"type": "boolean"}}, {}, "从理想温度显示开始执行已配置温程；到温后才计时保温。", ["program.running", "program.segment_index", "program.phase", "program.hold_elapsed_s", "thermal.target_k"]), + "thermal.stop_program": ({}, {"running": {"type": "boolean"}}, {}, "停止温程并将目标退回环境温度；不瞬间冷却。", ["program.running", "program.phase", "thermal.target_k"]), + } + caps = {} + for name, (inputs, outputs, example, description, immediate) in definitions.items(): + effects = [{"state_id": sid, "timing": "immediate", "description_zh": description} for sid in immediate] + if name != "thermal.configure_program": + effects += [{"state_id": sid, "timing": "on_step", "description_zh": "宿主推进的空炉热响应和理想显示。"} + for sid in ("thermal.temperature_k", "thermal.indicated_temperature_k")] + if name in ("thermal.start_program", "door.open", "door.close"): + effects += [{"state_id": sid, "timing": "on_step", "description_zh": "1s以内积分步长执行温程，门开时暂停；程序完成后目标退回环境。"} + for sid in ("program.running", "program.segment_index", "program.phase", "program.hold_elapsed_s", "thermal.target_k")] + observes = {"power.set": ["power.enabled"], "thermal.set_temperature": ["thermal.target_k"], + "door.open": ["door.angle_rad", "door.closed"], "door.close": ["door.angle_rad", "door.closed"], + "thermal.configure_program": ["program.segments"], "thermal.start_program": ["program.running"], "thermal.stop_program": ["program.running"]}[name] + preconditions = [] + if name in ("thermal.set_temperature", "thermal.configure_program", "thermal.start_program"): + preconditions.append("本机已上电。") + if name in ("thermal.set_temperature", "thermal.configure_program", "thermal.start_program"): + preconditions.append("温程未运行。") + if name in ("thermal.set_temperature", "thermal.configure_program"): + preconditions.append("温度目标不低于宿主环境，且不高于1373.15 K。") + if name == "thermal.start_program": + preconditions.append("已配置至少1段，且炉门已关闭。") + if name.startswith("door."): + preconditions.append("已注册同步场景回调；否则unsupported。") + caps[name] = {"availability": "implemented", "visibility": "agent", + "kind": "configuration" if name == "thermal.configure_program" else "device_command", + "description_zh": description, "input_schema": _object_schema(inputs), "output_schema": _object_schema(outputs), + "example_arguments": [example], "state_effects": effects, "observes": observes, + "binding": f"basic40_runtime_thermal.NaberthermL9Session.invoke(instance_id=..., capability_id='{name}', arguments=..., request_id=...)", + "scene_backend_required": name.startswith("door."), "preconditions_zh": preconditions, + "completion_criterion_zh": "返回值确认本次命令已处理；升温和程序完成须随后读取观测。"} + declared = {} + for name, description in {"thermal.program_library": "B410五程序存储库未实现；本运行层只有单个最多4段的模拟温程。", + "atmosphere.control": "保护气接口不是气密炉膛；本运行层不执行气氛控制。", + "sample.calcination": "未建立固相反应、灰化、负载热容或样品产物模型。"}.items(): + declared[name] = {"availability": "unsupported", "visibility": "agent", "kind": "device_command", + "description_zh": description, "input_schema": _object_schema({}), "output_schema": _object_schema({}), + "example_arguments": [{}], "state_effects": [], "observes": [], "binding": None} + def param(value, unit, evidence, description, uncertainty=None): + return {"value": value, "unit": unit, "evidence": evidence, "source": description, "uncertainty": uncertainty} + parameters = { + "heater_power_W": param(NABERTHERM_POWER_W, "W", "assumption", "2021目录第19页整机connected load为3.4kW，230V 1/N/PE；模型以该值作为最大等效热输入并随热容共同拟合，不是独立测得的加热器功率。", "电热效率与辅助电耗未独立识别；不混入新版3.7kW。"), + "maximum_temperature_K": param(NABERTHERM_MAX_K, "K", "public_document", "厂家最高1100°C。"), + "long_hold_recommended_temperature_K": param(NABERTHERM_REFERENCE_K, "K", "public_document", "厂家长保温建议1000°C；建议值不同于最高温度，不硬编码成硬件互锁。"), + "reference_heatup_s": param(NABERTHERM_REFERENCE_S, "s", "public_document", "空炉闭门、230V到Tmax−100K约75min；目录未说明初温。"), + "calibration_ambient_K": param(NABERTHERM_AMBIENT_K, "K", "assumption", "反推热容时假定初始和环境温度25°C。", "初温未由目录给定。"), + "heat_loss_W_K": param(NABERTHERM_LOSS_W_K, "W/K", "assumption", "闭门有效线性散热UA；一条升温点不足以同时识别C与UA。", "未实测；UA=1..3 W/K敏感性在calibration_report中。"), + "thermal_capacity_J_K": param(NABERTHERM_CAPACITY_J_K, "J/K", "derived", "C=-UA*t/log(1-UA*(Tref-Ta)/P)，由75min空炉点在明确UA、环境假设下反推；50kg整机质量未参与。", "条件拟合，不是炉衬/炉膛材料热容或独立实验验证。"), + "door_open_loss_W_K": param(NABERTHERM_OPEN_LOSS_W_K, "W/K", "assumption", "开门额外线性散热；仅用于仿真响应。", "开门冷却无厂家标定。"), + "maximum_door_angle_rad": param(NABERTHERM_DOOR_MAX_RAD, "rad", "assumption", "场景向下翻门+X轴0..90°，未测厂家关节极限。"), + "door_open_heater_fraction": param(0.0, "1", "public_document", "M01.1060 Rev2022-12 §6.6第54页：开门中断加热、关门自动恢复，LE例外不适用L...SKM；实现手册支持的门互锁行为，未作实机验证。"), + "program_maximum_segments": param(4, "1", "public_document", "B410每程序4段；只模拟一个程序，不实现五槽存储。"), + "program_maximum_ramp_rate_K_s": param(1.0, "K/s", "assumption", "目标斜率允许0.001..1K/s；真实升温仍受3400W和散热限制。"), + "program_hold_tolerance_K": param(0.5, "K", "assumption", "实际模型温度距段目标<=0.5K才累加保温；不声称厂家温控精度。"), + "program_integration_maximum_s": param(1.0, "s", "assumption", "温程状态机最大积分步长；转换时间分辨率<=1s。"), + } + host_caps = {"sim.step": {"kind": "simulation", "visibility": "trusted_host_only", + "input_schema": _object_schema({"dt_s": _number_schema("s", 0, 86400)}), + "binding": "basic40_runtime_thermal.NaberthermL9Runtime.step(dt_s)", + "completion_criterion": "所有注册实例推进同一时长，随后统一发布世界时钟。", + "partial_failure": "SceneSynchronizationError表示过程和时钟已推进；场景回调可有部分效果。"}} + return {"asset_types": {NABERTHERM_TYPE: {"catalog_id": "CHEM-185", "model": "Nabertherm L 9/11/SKM, catalogue configuration", + "asset_version": "1.0.0", "state_slots": slots, "capabilities": caps, "declared_capabilities": declared, + "parameters": parameters}}, "host_capabilities": host_caps, + "trusted_scene_callback": "scene_adapter(instance_id, updates): synchronous SI state updates; host owns door angle and display", + "result_schema_scope": "capability.output_schema validates response.result only"} + + +class NaberthermL9Runtime: + """Trusted multi-instance host. Do not expose host internals to agents.""" + def __init__(self, *, ambient_temperature_K=NABERTHERM_AMBIENT_K, scene_adapter=None): + if not _number(ambient_temperature_K) or not 273.15 <= ambient_temperature_K <= 313.15: + raise ValueError("Ambient temperature must be finite and within the assumed 273.15..313.15 K envelope") + self.ambient_temperature_K = float(ambient_temperature_K) + self.scene_adapter = scene_adapter + self.time_s = 0.0 + self._instances = {} + self._principals = {"__public_agent__": ("agent", None)} + self._requests = {} + self._logs = {"__public_agent__": []} + self._lock = threading.RLock() + self._metadata = export_nabertherm_contract_metadata() + self._agent = NaberthermL9Session(self, "__public_agent__") + + def create_instance(self, instance_id, asset_type_id=NABERTHERM_TYPE): + with self._lock: + if not isinstance(instance_id, str) or not instance_id or instance_id in self._instances or asset_type_id != NABERTHERM_TYPE: + raise ValueError("A unique nonempty instance ID and the declared Nabertherm type are required") + state = {"power.enabled": False, "thermal.target_k": self.ambient_temperature_K, + "thermal.temperature_k": self.ambient_temperature_K, + "thermal.indicated_temperature_k": round(self.ambient_temperature_K - 273.15, 1) + 273.15, + "door.angle_rad": 0.0, "door.closed": True, "heater.enabled": False, + "program.segments": [], "program.running": False, "program.segment_index": 0, + "program.phase": "idle", "program.hold_elapsed_s": 0.0} + if self.scene_adapter: + self.scene_adapter(instance_id, copy.deepcopy(state)) + self._instances[instance_id] = {"state": state, "revision": 0, "resume_phase": "ramp"} + + def register_principal(self, principal_id, *, visibility, instance_ids=None): + with self._lock: + if not isinstance(principal_id, str) or not principal_id or principal_id in self._principals or visibility not in ("agent", "debug", "evaluator"): + raise ValueError("Invalid or already registered host identity") + scope = None if instance_ids is None else frozenset(instance_ids) + if scope is not None and not scope <= self._instances.keys(): + raise ValueError("Unknown instance in identity scope") + self._principals[principal_id] = (visibility, scope) + self._logs[principal_id] = [] + + def session(self, principal_id): + if principal_id not in self._principals: + raise ValueError("Identity must be registered by trusted host") + return NaberthermL9Session(self, principal_id) + + def describe(self, **kwargs): + return self._agent.describe(**kwargs) + + def read(self, **kwargs): + return self._agent.read(**kwargs) + + def invoke(self, **kwargs): + return self._agent.invoke(**kwargs) + + def write(self, **kwargs): + return self._agent.write(**kwargs) + + def describe_host(self): + return copy.deepcopy(self._metadata["host_capabilities"]) + + def debug_snapshot(self): + with self._lock: + return copy.deepcopy({"time_s": self.time_s, "instances": self._instances}) + + def sync_scene(self, instance_ids=None): + with self._lock: + if self.scene_adapter is None: + raise RuntimeError("No scene adapter registered") + ids = list(self._instances) if instance_ids is None else list(instance_ids) + if any(key not in self._instances for key in ids): + raise ValueError("Unknown instance") + for key in ids: + try: + self.scene_adapter(key, copy.deepcopy(self._instances[key]["state"])) + except Exception: + raise SceneSynchronizationError("Scene synchronization failed; backend may have partial effects") from None + + def _thermal_step(self, state, dt): + ambient, old, target = self.ambient_temperature_K, state["thermal.temperature_k"], state["thermal.target_k"] + loss = NABERTHERM_LOSS_W_K + (0 if state["door.closed"] else NABERTHERM_OPEN_LOSS_W_K) + power = NABERTHERM_POWER_W if state["heater.enabled"] else 0.0 + decay = math.exp(-loss * dt / NABERTHERM_CAPACITY_J_K) + if not power or old >= target: + temperature = ambient + (old - ambient) * decay + if power and target > ambient: + temperature = max(target, temperature) + else: + equilibrium = ambient + power / loss + temperature = min(target, equilibrium + (old - equilibrium) * decay) + state["thermal.temperature_k"] = max(ambient, temperature) + state["thermal.indicated_temperature_k"] = round(state["thermal.temperature_k"] - 273.15, 1) + 273.15 + + def _advance(self, inst, dt): + s = inst["state"] + if not s["program.running"] or not s["door.closed"]: + self._thermal_step(s, dt) + return + remaining = dt + while remaining > 1e-12: + h = min(1.0, remaining) + if not s["program.running"]: + self._thermal_step(s, remaining) + break + segment = s["program.segments"][s["program.segment_index"]] + goal = segment["temperature_K"] + delta = goal - s["thermal.target_k"] + s["thermal.target_k"] += math.copysign(min(abs(delta), segment["ramp_rate_K_s"] * h), delta) if delta else 0 + before_close = abs(s["thermal.temperature_k"] - goal) <= 0.5 + self._thermal_step(s, h) + at_goal = abs(s["thermal.target_k"] - goal) <= 1e-9 and abs(s["thermal.temperature_k"] - goal) <= 0.5 + if at_goal: + was_hold = s["program.phase"] == "hold" + s["program.phase"] = "hold" + if before_close and was_hold: + s["program.hold_elapsed_s"] = min(segment["hold_s"], s["program.hold_elapsed_s"] + h) + if s["program.hold_elapsed_s"] >= segment["hold_s"]: + s["program.segment_index"] += 1 + if s["program.segment_index"] == len(s["program.segments"]): + s["program.running"] = False + s["program.phase"] = "completed" + s["thermal.target_k"] = self.ambient_temperature_K + else: + s["program.phase"] = "ramp" + s["program.hold_elapsed_s"] = 0.0 + remaining -= h + + def step(self, dt_s): + if not _number(dt_s) or not 0 <= dt_s <= 86400: + raise ValueError("Host time step must be finite and within 0..86400 s") + if not dt_s: + return + with self._lock: + for inst in self._instances.values(): + self._advance(inst, float(dt_s)) + inst["revision"] += 1 + self.time_s += dt_s + if self.scene_adapter: + failures = [] + for key, inst in self._instances.items(): + try: + self.scene_adapter(key, copy.deepcopy(inst["state"])) + except Exception: + failures.append(key) + if failures: + raise SceneSynchronizationError("World process and clock advanced; scene synchronization failed") from None + + +class NaberthermL9Session: + """Public uniform adapter. Identity cannot be supplied in read/invoke args.""" + def __init__(self, host, principal_id): + self.__host, self.__principal = host, principal_id + + def _visible(self, slot): + return slot["visibility"] == "agent" or self.__host._principals[self.__principal][0] in ("debug", "evaluator") + + def _instance(self, instance_id): + if not isinstance(instance_id, str): + return None + _, scope = self.__host._principals[self.__principal] + return self.__host._instances.get(instance_id) if scope is None or instance_id in scope else None + + def _envelope(self, instance_id, request_id=None, *, result=None, observations=None, status="succeeded", error=None): + inst = self._instance(instance_id) + return {"protocol_version": PROTOCOL_VERSION, "instance_id": instance_id if isinstance(instance_id, str) else None, + "request_id": request_id if isinstance(request_id, str) else None, "operation_id": None, "status": status, + "state_revision": inst["revision"] if inst else None, "clock": {"domain": "simulation", "time_s": self.__host.time_s}, + "result": {} if result is None else copy.deepcopy(result), "observations": {} if observations is None else observations, "error": error} + + def _error(self, instance_id, code, request_id=None, status="rejected"): + messages = {"UNKNOWN_INSTANCE": "Instance is unavailable in this session.", "UNKNOWN_CAPABILITY": "Capability is unavailable.", + "INVALID_ARGUMENT": "Arguments do not meet declared schema or limits.", "ACCESS_DENIED": "Request is outside session access policy.", + "PRECONDITION_FAILED": "Required operating state or configuration is unavailable.", "BUSY": "Stop the active program first.", + "REQUEST_CONFLICT": "Request ID already belongs to different arguments.", "UNSUPPORTED": "Execution is unavailable in this adapter.", + "DEVICE_ERROR": "Scene callback did not complete the command."} + return self._envelope(instance_id, request_id, status=status, error={"code": code, "message": messages[code], + "retryable": False, "side_effects": "unknown" if code == "DEVICE_ERROR" else "none", "progress": None}) + + def describe(self, *, asset_type_id=None, instance_id=None): + with self.__host._lock: + if (asset_type_id is None) == (instance_id is None): + return self._error(None, "INVALID_ARGUMENT") + if instance_id is not None and not self._instance(instance_id): + return self._error(instance_id, "UNKNOWN_INSTANCE") + if asset_type_id is not None and asset_type_id != NABERTHERM_TYPE: + return self._error(None, "INVALID_ARGUMENT") + _, scope = self.__host._principals[self.__principal] + if scope is not None and not scope: + return self._error(instance_id, "ACCESS_DENIED") + spec = copy.deepcopy(self.__host._metadata["asset_types"][NABERTHERM_TYPE]) + spec["state_slots"] = {sid: slot for sid, slot in spec["state_slots"].items() if self._visible(slot)} + spec["capabilities"].update(spec.pop("declared_capabilities")) + for cap in spec["capabilities"].values(): + # Hidden state IDs must not be reintroduced through metadata effects. + cap["state_effects"] = [effect for effect in cap["state_effects"] if effect["state_id"] in spec["state_slots"]] + cap["observes"] = [sid for sid in cap["observes"] if sid in spec["state_slots"]] + if cap.get("scene_backend_required") and self.__host.scene_adapter is None: + cap["availability"] = "unsupported" + return {"protocol_version": PROTOCOL_VERSION, "asset_type_id": NABERTHERM_TYPE, "instance_id": instance_id, + "adapter": "basic40_runtime_thermal.NaberthermL9Session", **spec, + "limitations": ["Synthetic empty-furnace process; no sample chemistry, robot or hardware execution.", + "API truth filtering does not isolate Python introspection or files.", + "Displayed temperature is rounded to 0.1 Celsius and marked estimated.", + "Program ramp is commanded target slope; delivered heating remains power limited.", + "One program of up to four stages; no B410 five-program store.", + "Open-door heating inhibition follows the product-family manual; open-door extra loss is an unmeasured assumption.", + "1000 Celsius is the recommended prolonged hold temperature; 1100 Celsius is maximum.", + "In-memory deduplication does not survive host restart."]} + + def read(self, *, instance_id, state_ids=None): + with self.__host._lock: + inst = self._instance(instance_id) + if not inst: + return self._error(instance_id, "UNKNOWN_INSTANCE") + slots = self.__host._metadata["asset_types"][NABERTHERM_TYPE]["state_slots"] + if state_ids is None: + state_ids = [sid for sid, slot in slots.items() if self._visible(slot)] + if not isinstance(state_ids, list) or any(not isinstance(sid, str) for sid in state_ids) or len(state_ids) != len(set(state_ids)): + return self._error(instance_id, "INVALID_ARGUMENT") + if any(sid not in slots or not self._visible(slots[sid]) for sid in state_ids): + return self._error(instance_id, "ACCESS_DENIED") + observations = {sid: {"value": copy.deepcopy(inst["state"][sid]), "unit": slots[sid]["unit"], + "quality": "estimated" if slots[sid]["origin"] == "derived" else "valid", + "sample_time_s": self.__host.time_s, "sample_window_s": None} for sid in state_ids} + return self._envelope(instance_id, observations=observations) + + def invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if not inst: + return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + if not isinstance(capability_id, str) or not isinstance(arguments, dict) or not isinstance(request_id, str) or not request_id or len(request_id) > 256: + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + try: + digest = hashlib.sha256(json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False).encode()).hexdigest() + except (TypeError, ValueError, OverflowError): + return self._error(instance_id, "INVALID_ARGUMENT", request_id) + key = (self.__principal, instance_id, request_id) + if key in host._requests: + old_digest, response = host._requests[key] + return copy.deepcopy(response) if old_digest == digest else self._error(instance_id, "REQUEST_CONFLICT", request_id) + response = self._checked(instance_id, inst, capability_id, arguments, request_id) + host._requests[key] = (digest, copy.deepcopy(response)) + host._logs[self.__principal].append({"instance_id": instance_id, "capability_id": capability_id, "request_id": request_id, "response": copy.deepcopy(response)}) + return response + + def _checked(self, instance_id, inst, cap, args, request_id): + host, old = self.__host, inst["state"] + spec = host._metadata["asset_types"][NABERTHERM_TYPE] + fail = lambda code, status="rejected": self._error(instance_id, code, request_id, status) + if cap in spec["declared_capabilities"]: + return fail("UNSUPPORTED", "unsupported") + if cap not in spec["capabilities"]: + return fail("UNKNOWN_CAPABILITY") + if set(args) != set(spec["capabilities"][cap]["input_schema"]["properties"]): + return fail("INVALID_ARGUMENT") + if cap == "power.set" and type(args["enabled"]) is not bool: + return fail("INVALID_ARGUMENT") + if cap == "thermal.set_temperature" and (not _number(args["temperature_K"]) or not host.ambient_temperature_K <= args["temperature_K"] <= NABERTHERM_MAX_K): + return fail("INVALID_ARGUMENT") + if cap == "thermal.configure_program": + segments = args["segments"] + if not isinstance(segments, list) or not 1 <= len(segments) <= 4: + return fail("INVALID_ARGUMENT") + for segment in segments: + if not isinstance(segment, dict) or set(segment) != {"temperature_K", "ramp_rate_K_s", "hold_s"} or not all(_number(value) for value in segment.values()): + return fail("INVALID_ARGUMENT") + if not (host.ambient_temperature_K <= segment["temperature_K"] <= NABERTHERM_MAX_K and 0.001 <= segment["ramp_rate_K_s"] <= 1 and 0 <= segment["hold_s"] <= 86400): + return fail("INVALID_ARGUMENT") + if cap in ("thermal.set_temperature", "thermal.configure_program", "thermal.start_program"): + if not old["power.enabled"]: + return fail("PRECONDITION_FAILED") + if old["program.running"]: + return fail("BUSY") + if cap == "thermal.start_program" and (not old["program.segments"] or not old["door.closed"]): + return fail("PRECONDITION_FAILED") + if cap.startswith("door.") and host.scene_adapter is None: + return fail("UNSUPPORTED", "unsupported") + state = copy.deepcopy(old) + resume_phase = inst["resume_phase"] + if cap == "power.set": + state["power.enabled"] = args["enabled"] + state["heater.enabled"] = args["enabled"] and state["door.closed"] + if not args["enabled"] and state["program.running"]: + state["program.running"], state["program.phase"] = False, "stopped" + result = {"enabled": args["enabled"]} + elif cap == "thermal.set_temperature": + state["thermal.target_k"] = float(args["temperature_K"]) + result = {"setpoint_K": state["thermal.target_k"]} + elif cap.startswith("door."): + closed = cap == "door.close" + state["door.angle_rad"], state["door.closed"] = (0.0 if closed else NABERTHERM_DOOR_MAX_RAD), closed + state["heater.enabled"] = state["power.enabled"] and closed + if state["program.running"]: + if not closed and state["program.phase"] != "paused_door": + resume_phase, state["program.phase"] = state["program.phase"], "paused_door" + elif closed and state["program.phase"] == "paused_door": + state["program.phase"] = resume_phase + result = {"angle_rad": state["door.angle_rad"], "closed": closed} + elif cap == "thermal.configure_program": + state["program.segments"] = copy.deepcopy(args["segments"]) + state["program.segment_index"], state["program.phase"], state["program.hold_elapsed_s"] = 0, "idle", 0.0 + result = {"segment_count": len(args["segments"])} + elif cap == "thermal.start_program": + state["program.running"], state["program.phase"], state["program.segment_index"], state["program.hold_elapsed_s"] = True, "ramp", 0, 0.0 + state["thermal.target_k"] = max(host.ambient_temperature_K, state["thermal.indicated_temperature_k"]) + result = {"running": True} + else: + state["program.running"], state["program.phase"] = False, "stopped" + state["thermal.target_k"] = host.ambient_temperature_K + result = {"running": False} + updates = {sid: copy.deepcopy(value) for sid, value in state.items() if value != old[sid]} + if host.scene_adapter: + try: + host.scene_adapter(instance_id, updates) + except Exception: + return fail("DEVICE_ERROR", "failed") + inst["state"], inst["resume_phase"] = state, resume_phase + inst["revision"] += 1 + return self._envelope(instance_id, request_id, result=result) + + def write(self, *, instance_id, state_id, value, request_id): + with self.__host._lock: + if not self._instance(instance_id): + return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + slots = self.__host._metadata["asset_types"][NABERTHERM_TYPE]["state_slots"] + if not isinstance(state_id, str) or state_id not in slots or not self._visible(slots[state_id]) or not slots[state_id]["write_via"]: + return self._error(instance_id, "ACCESS_DENIED", request_id) + route = slots[state_id]["write_via"] + return self.invoke(instance_id=instance_id, capability_id=route["capability_id"], arguments={route["parameter"]: value}, request_id=request_id) + + def logs(self): + with self.__host._lock: + return copy.deepcopy(self.__host._logs[self.__principal]) + + +def nabertherm_calibration_report(): + assumptions = [] + for loss in (1.0, 2.0, 3.0): + capacity = -loss * NABERTHERM_REFERENCE_S / math.log1p(-loss * (NABERTHERM_REFERENCE_K - NABERTHERM_AMBIENT_K) / NABERTHERM_POWER_W) + assumptions.append({"assumed_closed_loss_W_K": loss, "fitted_effective_capacity_J_K": capacity, + "predicted_time_to_1000C_s": -capacity / loss * math.log1p(-loss * 975 / 3400), + "predicted_power_off_1000C_to_100C_s": capacity / loss * math.log(975 / 75)}) + host = NaberthermL9Runtime() + host.create_instance("calibration_fixture") + host.invoke(instance_id="calibration_fixture", capability_id="power.set", arguments={"enabled": True}, request_id="power") + host.invoke(instance_id="calibration_fixture", capability_id="thermal.set_temperature", arguments={"temperature_K": NABERTHERM_MAX_K}, request_id="temperature") + host.step(4500) + actual = host.debug_snapshot()["instances"]["calibration_fixture"]["state"]["thermal.temperature_k"] + return {"schema_version": "1.0.0", "catalog_id": "CHEM-185", "recorded_at": datetime.now(timezone.utc).isoformat(), + "source": NABERTHERM_SOURCE, "manufacturer_conditions": "Empty furnace, closed door, 230 V 1/N/PE; Tmax minus 100 K in approximately 75 min.", + "model": "C*dT/dt=P-UA*(T-Ta); exact exponential for constant target/door; ideal cap at setpoint.", + "calibration_equation": "C=-UA*t_ref/ln(1-UA*(T_ref-Ta)/P)", + "assumed_initial_and_ambient_K": NABERTHERM_AMBIENT_K, "rated_power_W": NABERTHERM_POWER_W, + "assumed_closed_loss_W_K": NABERTHERM_LOSS_W_K, "fitted_effective_capacity_J_K": NABERTHERM_CAPACITY_J_K, + "target_at_4500s_K": NABERTHERM_REFERENCE_K, "runtime_at_4500s_K": actual, "error_K": actual - NABERTHERM_REFERENCE_K, + "whole_instrument_mass_kg": 50.0, "whole_mass_used_as_component_capacity": False, + "electrical_power_interpretation": "3400 W is catalogue connected load; treating it as maximum effective thermal input is a modeling assumption absorbed into the fitted capacity, not a measured heater efficiency.", + "independent_catalogue_endpoint_comparison": {"source": NABERTHERM_MANUAL + "#page=25", + "manufacturer_approximate_time_to_1100C_s": 5400.0, + "predicted_time_to_1100C_s": -NABERTHERM_CAPACITY_J_K / NABERTHERM_LOSS_W_K * math.log1p(-NABERTHERM_LOSS_W_K * (NABERTHERM_MAX_K - NABERTHERM_AMBIENT_K) / NABERTHERM_POWER_W), + "interpretation": "Additional endpoint from old 3.4kW manual table; approximate-condition comparison, not independent experimental validation."}, + "door_interlock_source": NABERTHERM_MANUAL + "#page=54", + "sensitivity": assumptions, + "evidence_status": "Conditional calibration to one catalogue heat-up point; not independent measured validation.", + "uncertainty": ["Catalogue does not specify initial temperature or uncertainty of approximate 75 min.", + "One time-temperature point cannot independently identify both effective capacity and loss coefficient.", + "Loss is effective and linear: no separately calibrated radiation, insulation layers, chamber-air or crucible nodes.", + "Cooling and open-door parameters have no manufacturer transient calibration.", + "Whole-instrument 50 kg does not identify any component mass or heat capacity."]} + + +def validate_nabertherm_runtime(output_directory): + test_path = Path(__file__).resolve().parents[1] / "tests/test_basic40_thermal.py" + spec = importlib.util.spec_from_file_location("nabertherm_runtime_tests", test_path) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + stream = io.StringIO() + result = unittest.TextTestRunner(stream=stream, verbosity=2).run(unittest.defaultTestLoader.loadTestsFromModule(module)) + report = {"schema_version": "1.0.0", "catalog_id": "CHEM-185", "recorded_at": datetime.now(timezone.utc).isoformat(), + "method": "unittest of real NaberthermL9Runtime and NaberthermL9Session public APIs with trusted host step", + "environment": {"python": platform.python_version(), "platform": platform.platform()}, + "data_classification": "Synthetic fixtures; no private or real sample data.", + "result": "passed" if result.wasSuccessful() else "failed", "tests_run": result.testsRun, + "failures": len(result.failures), "errors": len(result.errors), "log": stream.getvalue(), + "layers": {"process": "passed" if result.wasSuccessful() else "failed", "host": "passed" if result.wasSuccessful() else "failed", + "scene": "not_run", "robot": "not_run", "hardware": "not_run"}, + "limitations": ["Recording callbacks verify host synchronization only, not evaluated geometry.", + "Thermal calibration fits one approximate catalogue point under explicit loss and ambient assumptions.", + "API truth filtering tested; shared-process/filesystem security isolation not implemented."]} + directory = Path(output_directory) + directory.mkdir(parents=True, exist_ok=True) + for name, value in (("thermal_runtime_validation.json", report), ("thermal_calibration.json", nabertherm_calibration_report()), + ("thermal_runtime_metadata.json", export_nabertherm_contract_metadata())): + (directory / name).write_text(json.dumps(value, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument("--validate", type=Path, metavar="OUTPUT_DIRECTORY") + options = parser.parse_args() + if options.validate: + report = validate_nabertherm_runtime(options.validate) + print(json.dumps({key: report[key] for key in ("result", "tests_run", "failures", "errors")}, indent=2)) + raise SystemExit(0 if report["result"] == "passed" else 1) + parser.print_help() + +# BEGIN CHEM-186 Carbolite TF1 runtime: append-only shared thermal module. +import copy as _tf1_copy +import hashlib as _tf1_hashlib +import json as _tf1_json +import math as _tf1_math +import threading as _tf1_threading + +CARBOLITE_TF1_ASSET_TYPE = 'instrument.carbolite_tf1_12_60_300' +CARBOLITE_TF1_SOURCE_URL = 'https://www.carbolite.com/products/tube-furnace-range/universal-tube-furnaces/tf-range/' +CARBOLITE_TF1_PARAMETERS = { + 'heater_power_W': {'value': 1500.0, 'unit': 'W', 'evidence': 'public_document', 'source': CARBOLITE_TF1_SOURCE_URL + ' — TF1 12/60/300 technical table: maximum power 1500 W'}, + 'maximum_temperature_K': {'value': 1473.15, 'unit': 'K', 'evidence': 'public_document', 'source': CARBOLITE_TF1_SOURCE_URL + ' — maximum temperature 1200 deg C'}, + 'maximum_continuous_temperature_K': {'value': 1373.15, 'unit': 'K', 'evidence': 'public_document', 'source': CARBOLITE_TF1_SOURCE_URL + ' — continuous temperature 1100 deg C'}, + 'reference_heatup_time_s': {'value': 2100.0, 'unit': 's', 'evidence': 'public_document', 'source': CARBOLITE_TF1_SOURCE_URL + ' — 35 min to 100 deg C below maximum, empty quartz work tube and insulation plugs'}, + 'reference_heatup_temperature_K': {'value': 1373.15, 'unit': 'K', 'evidence': 'public_document', 'source': CARBOLITE_TF1_SOURCE_URL + ' — 1200 - 100 = 1100 deg C'}, + 'reference_ambient_temperature_K': {'value': 293.15, 'unit': 'K', 'evidence': 'assumption', 'source': 'Assumed 20 deg C start; manufacturer heat-up table does not state starting ambient.'}, + 'heat_loss_W_K': {'value': 0.5, 'unit': 'W/K', 'evidence': 'assumption', 'source': 'Assumed effective UA, giving 540 W loss at 1100 deg C and 20 deg C ambient (36% of rated power). One manufacturer heat-up point cannot identify both C and UA; no cooldown/hold-power calibration.'}, + 'thermal_capacity_J_K': {'value': -0.5 * 2100.0 / _tf1_math.log(1.0 - 0.5 * 1080.0 / 1500.0), 'unit': 'J/K', 'evidence': 'assumption', 'source': 'Effective empty-system C = -UA*t/log(1-UA*(Tref-Tambient)/P), from 1500 W / 2100 s manufacturer heat-up point, assumed UA=0.5 W/K and ambient=293.15 K. This is not the measured heat capacity of any component.'}, + 'work_tube_inner_diameter_m': {'value': None, 'unit': 'm', 'evidence': 'unknown', 'source': '60 mm is furnace bore / maximum work-tube outer diameter, not the work-tube inner diameter.'}, + 'work_tube_mass_kg': {'value': None, 'unit': 'kg', 'evidence': 'unknown', 'source': 'Selected work-tube material, wall thickness and mass are unconfirmed.'}, + 'end_seal_mass_kg': {'value': None, 'unit': 'kg', 'evidence': 'unknown', 'source': 'Individual end-seal component mass is unconfirmed.'}, + 'gas_flow_rate_m3_s': {'value': None, 'unit': 'm^3/s', 'evidence': 'unknown', 'source': 'No flow controller, supply condition, conductance or flow measurement is configured.'}, + 'gas_pressure_pa': {'value': None, 'unit': 'Pa', 'evidence': 'unknown', 'source': 'No absolute-pressure state solver or sensor is configured.'}, + 'maximum_end_seal_withdrawal_m': {'value': 0.12, 'unit': 'm', 'evidence': 'assumption', 'source': 'Illustrative removable-part scene travel, not a manufacturer actuator stroke.'}, + 'minimum_end_seal_clearance_m': {'value': 0.10, 'unit': 'm', 'evidence': 'assumption', 'source': 'Scene clearance rule before work-tube translation; not measured collision clearance.'}, + 'maximum_work_tube_withdrawal_m': {'value': 0.8, 'unit': 'm', 'evidence': 'assumption', 'source': 'Illustrative work-tube scene travel along +X; not a manufacturer actuator stroke.'}, +} + + +def _carbolite_tf1_number(value): + try: + return type(value) in (int, float) and _tf1_math.isfinite(value) + except (OverflowError, TypeError): + return False + + +def _carbolite_tf1_slot(unit, origin, visibility='agent', route=None, schema=None): + return {'unit': unit, 'origin': origin, 'visibility': visibility, + 'access': 'read_write' if route else 'read_only', + 'write_via': route, 'value_schema': schema or {'type': 'number'}, + 'read_binding': 'CarboliteTF1Session.read(instance_id=..., state_ids=[state_id])', + 'sampling': {'mode': 'instant', 'time_domain': 'simulation', 'window': None}, + 'reference_conditions': None} + + +CARBOLITE_TF1_STATE_SLOTS = { + 'power.enabled': _carbolite_tf1_slot('1', 'setpoint', route={'capability_id': 'power.set', 'parameter': 'enabled', 'fixed_arguments': {}}, schema={'type': 'boolean'}), + 'thermal.target_k': _carbolite_tf1_slot('K', 'setpoint', route={'capability_id': 'thermal.set_temperature', 'parameter': 'temperature_K', 'fixed_arguments': {}}), + 'thermal.temperature_k': _carbolite_tf1_slot('K', 'process_truth', 'debug'), + 'thermal.indicated_temperature_k': _carbolite_tf1_slot('K', 'derived'), + 'thermal.heater_energy_j': _carbolite_tf1_slot('J', 'process_truth', 'debug'), + 'thermal.heat_loss_energy_j': _carbolite_tf1_slot('J', 'process_truth', 'debug'), + 'thermal.stored_energy_j': _carbolite_tf1_slot('J', 'process_truth', 'debug'), + 'end_seal.left.withdrawal_m': _carbolite_tf1_slot('m', 'scene', route={'capability_id': 'scene.set_end_seal', 'parameter': 'withdrawal_m', 'fixed_arguments': {'side': 'left'}}), + 'end_seal.right.withdrawal_m': _carbolite_tf1_slot('m', 'scene', route={'capability_id': 'scene.set_end_seal', 'parameter': 'withdrawal_m', 'fixed_arguments': {'side': 'right'}}), + 'work_tube.withdrawal_m': _carbolite_tf1_slot('m', 'scene', route={'capability_id': 'scene.set_work_tube', 'parameter': 'withdrawal_m', 'fixed_arguments': {}}), + 'gas.inlet.connected': _carbolite_tf1_slot('1', 'scene', route={'capability_id': 'scene.set_gas_connection', 'parameter': 'connected', 'fixed_arguments': {'port_id': 'gas_inlet'}}, schema={'type': 'boolean'}), + 'gas.outlet.connected': _carbolite_tf1_slot('1', 'scene', route={'capability_id': 'scene.set_gas_connection', 'parameter': 'connected', 'fixed_arguments': {'port_id': 'gas_outlet'}}, schema={'type': 'boolean'}), + 'gas.flow_rate_m3_s': _carbolite_tf1_slot('m^3/s', 'process_truth', 'debug', schema={'anyOf': [{'type': 'number'}, {'type': 'null'}]}), + 'gas.pressure_pa': _carbolite_tf1_slot('Pa', 'process_truth', 'debug', schema={'anyOf': [{'type': 'number'}, {'type': 'null'}]}), +} +CARBOLITE_TF1_STATE_SLOTS['gas.flow_rate_m3_s']['reference_conditions'] = 'Unspecified: no gas flow is calculated or measured; value remains null.' +CARBOLITE_TF1_STATE_SLOTS['gas.pressure_pa']['reference_conditions'] = 'Absolute pressure would be required; currently unavailable (null).' +for _carbolite_tf1_sid in ('thermal.heater_energy_j', 'thermal.heat_loss_energy_j'): + CARBOLITE_TF1_STATE_SLOTS[_carbolite_tf1_sid]['sampling'] = {'mode': 'integral', 'time_domain': 'simulation', 'window': 'Accumulated since instance creation.'} + + +def _carbolite_tf1_effect(state_id, timing, note): + return {'state_id': state_id, 'timing': timing, 'description_zh': note} + + +def carbolite_tf1_metadata(): + """Type-only schema metadata, with no instance values or host credentials.""" + thermal_effects = [_carbolite_tf1_effect(sid, 'on_step', '宿主推进空载集中热模型；不模拟反应、样品、气流或实测传感器。') for sid in ('thermal.temperature_k', 'thermal.indicated_temperature_k', 'thermal.heater_energy_j', 'thermal.heat_loss_energy_j', 'thermal.stored_energy_j')] + definitions = { + 'power.set': ({'enabled': {'type': 'boolean'}}, {'enabled': {'type': 'boolean'}}, '设置仿真供电；开机要求工作管完全归位。', {'enabled': True}, ['power.enabled'], ['power.enabled'], 'enabled=true requires work_tube.withdrawal_m == 0; a scene configuration rule, not a manufacturer safety interlock.'), + 'thermal.set_temperature': ({'temperature_K': {'type': 'number', 'minimum': 273.15, 'maximum': 1473.15, 'x-unit': 'K', 'description': 'Finite; actual minimum is host ambient. Above 1373.15 K exceeds manufacturer continuous rating; maximum-temperature dwell is not simulated.'}}, {'setpoint_K': {'type': 'number', 'x-unit': 'K'}}, '只写温度目标；实际温度与能量只在宿主 step 演化。', {'temperature_K': 1373.15}, ['thermal.target_k'], ['thermal.target_k'], 'power.enabled == true and ambient_temperature_K <= temperature_K <= 1473.15.'), + 'scene.set_end_seal': ({'side': {'type': 'string', 'enum': ['left', 'right']}, 'withdrawal_m': {'type': 'number', 'minimum': 0, 'maximum': 0.12, 'x-unit': 'm'}}, {'side': {'type': 'string', 'enum': ['left', 'right']}, 'withdrawal_m': {'type': 'number', 'x-unit': 'm'}}, '设置可拆端封示意轴向移位；左向-X、右向+X，无机器人或接触求解。', {'side': 'left', 'withdrawal_m': 0.12}, ['end_seal.left.withdrawal_m', 'end_seal.right.withdrawal_m'], ['end_seal.left.withdrawal_m', 'end_seal.right.withdrawal_m'], 'Requires scene backend; power off and corresponding gas port disconnected when changing position. If work tube is displaced, seal cannot move below 0.10 m. These are scene rules, not manufacturer interlocks.'), + 'scene.set_work_tube': ({'withdrawal_m': {'type': 'number', 'minimum': 0, 'maximum': 0.8, 'x-unit': 'm'}}, {'withdrawal_m': {'type': 'number', 'x-unit': 'm'}}, '设置工作管沿+X的示意拆卸移位；工作管内径未知。', {'withdrawal_m': 0.8}, ['work_tube.withdrawal_m'], ['work_tube.withdrawal_m'], 'Requires scene backend; power off, both seals withdrawn at least 0.10 m, and both gas ports disconnected when changing position. No hot handling, grasping or collision safety claim.'), + 'scene.set_gas_connection': ({'port_id': {'type': 'string', 'enum': ['gas_inlet', 'gas_outlet']}, 'connected': {'type': 'boolean'}}, {'port_id': {'type': 'string', 'enum': ['gas_inlet', 'gas_outlet']}, 'connected': {'type': 'boolean'}}, '记录气口连接标志；气压、流量、密封性、置换和气氛组成均未求解。', {'port_id': 'gas_inlet', 'connected': True}, ['gas.inlet.connected', 'gas.outlet.connected'], ['gas.inlet.connected', 'gas.outlet.connected'], 'Requires scene backend. Connecting requires power off, associated seal at zero withdrawal and work tube at zero withdrawal. Disconnect is always allowed; this records configuration, not a physical coupling operation.'), + } + capabilities = {} + for name, (inputs, outputs, description, example, effects, observes, precondition) in definitions.items(): + capabilities[name] = { + 'availability': 'implemented', 'visibility': 'agent', + 'kind': 'simulation' if name.startswith('scene.') else 'device_command', + 'description_zh': description, + 'input_schema': {'type': 'object', 'properties': inputs, 'required': list(inputs), 'additionalProperties': False}, + 'output_schema': {'type': 'object', 'properties': outputs, 'required': list(outputs), 'additionalProperties': False}, + 'state_effects': [_carbolite_tf1_effect(sid, 'immediate', '只更新本次选择的状态槽；不相关侧保持不变。') for sid in effects] + (thermal_effects if name in ('power.set', 'thermal.set_temperature') else []), + 'observes': observes, 'example_arguments': [example], + 'preconditions': precondition, + 'binding': "basic40_runtime_thermal.CarboliteTF1Session.invoke(instance_id=..., capability_id='" + name + "', arguments=..., request_id=...)", + 'completion_criterion': 'Declared command value committed; synchronous scene callback returned where configured. Temperature settling is not command completion.', + 'retry_semantics': 'In-memory per-principal/instance/request ID deduplication; mismatched command returns REQUEST_CONFLICT. No restart persistence.', + } + return {'protocol_version': '1.0.0', 'asset_type_id': CARBOLITE_TF1_ASSET_TYPE, 'asset_version': '1.0.0', 'catalog_id': 'CHEM-186', 'model': 'Carbolite Gero TF1 12/60/300', + 'state_slots': _tf1_copy.deepcopy(CARBOLITE_TF1_STATE_SLOTS), 'capabilities': capabilities, 'parameters': _tf1_copy.deepcopy(CARBOLITE_TF1_PARAMETERS), + 'limitations': ['Synthetic empty hot-zone lumped model, derived from the manufacturer 35-minute heat-up point with assumed 20 deg C ambient and UA; C and UA are not separately identifiable from that one point.', + 'Maximum rated temperature is 1473.15 K; continuous manufacturer rating is 1373.15 K. This model does not enforce dwell-time limits or model degradation above the continuous rating.', + 'Reference manufacturer heat-up configuration uses an empty quartz work tube and insulation plugs. Removal/seal position does not alter thermal coefficients; other configurations and cooldown are uncalibrated.', + 'No sample temperature gradients, chemical kinetics, purge, pressure, gas flow, oxygen concentration, vacuum integrity, robot operation, collision safety, or hardware driver.', + 'Scene sliding coordinates are an illustrative disassembly aid, not real motors or a furnace door hinge.', + 'Indicated temperature is an estimated ideal display rounded on a 0.1 deg C grid and exposed in K, not a measured sensor accuracy claim.', + 'Only trusted host step advances the shared TF1-world clock. Python API visibility filtering does not isolate Python introspection, shared memory or filesystem access; use a separate trusted host process for untrusted agents.']} + + +class CarboliteTF1SceneSynchronizationError(RuntimeError): + """Process and common host clock committed; scene synchronization failed.""" + + +class CarboliteTF1Runtime: + """Trusted host for independent TF1 instances; never expose to an untrusted agent. + + scene_adapter(instance_id, updates) must be synchronous and atomic where possible. + It receives SI-valued slots and must not write the runtime. Robot/hardware work is + not implemented. Scene failures are reported, not represented as false success. + """ + def __init__(self, *, ambient_temperature_K=293.15, scene_adapter=None): + if not _carbolite_tf1_number(ambient_temperature_K) or not 273.15 <= ambient_temperature_K <= 313.15: + raise ValueError('Ambient must be finite and within assumed 273.15–313.15 K range.') + self.ambient_temperature_K = float(ambient_temperature_K) + self.time_s = 0.0 + self.scene_adapter = scene_adapter + self._instances = {} + self._principals = {} + self._requests = {} + self._logs = {} + self._scene_faults = [] + self._lock = _tf1_threading.RLock() + + def create_instance(self, instance_id, asset_type_id=CARBOLITE_TF1_ASSET_TYPE): + with self._lock: + if not isinstance(instance_id, str) or not instance_id or instance_id in self._instances: + raise ValueError('Instance ID must be nonempty and unique.') + if asset_type_id != CARBOLITE_TF1_ASSET_TYPE: + raise ValueError('Unsupported asset type.') + state = {sid: 0.0 for sid in CARBOLITE_TF1_STATE_SLOTS} + state.update({'power.enabled': False, 'thermal.target_k': self.ambient_temperature_K, 'thermal.temperature_k': self.ambient_temperature_K, + 'thermal.indicated_temperature_k': round(self.ambient_temperature_K - 273.15, 1) + 273.15, 'gas.inlet.connected': False, 'gas.outlet.connected': False, + 'gas.flow_rate_m3_s': None, 'gas.pressure_pa': None}) + if self.scene_adapter: + self.scene_adapter(instance_id, _tf1_copy.deepcopy(state)) + self._instances[instance_id] = {'state': state, 'revision': 0, 'created_at_s': self.time_s} + + def register_principal(self, principal_id, *, visibility, instance_ids=None): + with self._lock: + if not isinstance(principal_id, str) or not principal_id or principal_id in self._principals or visibility not in ('agent', 'debug', 'evaluator'): + raise ValueError('Principal identity and role must be host-assigned and unique.') + if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(sid, str) or sid not in self._instances for sid in instance_ids)): + raise ValueError('Instance scope must contain registered IDs.') + self._principals[principal_id] = (visibility, None if instance_ids is None else frozenset(instance_ids)) + self._logs[principal_id] = [] + + def session(self, principal_id): + with self._lock: + if not isinstance(principal_id, str) or principal_id not in self._principals: + raise ValueError('Register host identity before creating a session.') + return CarboliteTF1Session(self, principal_id) + + def describe_host(self): + return {'sim.step': {'visibility': 'trusted_host_only', 'kind': 'simulation', + 'input_schema': {'type': 'object', 'properties': {'dt_s': {'type': 'number', 'minimum': 0, 'maximum': 3600, 'x-unit': 's'}}, 'required': ['dt_s'], 'additionalProperties': False}, + 'binding': 'CarboliteTF1Runtime.step(dt_s)', 'scope': 'All TF1 instances registered with this host share one world clock.'}} + + def sync_scene(self, instance_ids=None): + if self.scene_adapter is None: + raise RuntimeError('No scene backend is registered.') + with self._lock: + ids = list(self._instances) if instance_ids is None else instance_ids + if not isinstance(ids, (list, tuple)) or any(not isinstance(sid, str) or sid not in self._instances for sid in ids): + raise ValueError('Unknown scene instance.') + for sid in ids: + try: + self.scene_adapter(sid, _tf1_copy.deepcopy(self._instances[sid]['state'])) + except Exception: + self._scene_faults.append({'instance_id': sid, 'time_s': self.time_s, 'code': 'SCENE_SYNC_FAILED'}) + raise CarboliteTF1SceneSynchronizationError('Scene resynchronization failed; external effects may be partial.') from None + + def _thermal_step(self, inst, dt_s): + """Exact constant-UA ODE segments and ideal target hold, with joule ledger.""" + state = inst['state'] + ambient = self.ambient_temperature_K + old = state['thermal.temperature_k'] + target = state['thermal.target_k'] + capacity = CARBOLITE_TF1_PARAMETERS['thermal_capacity_J_K']['value'] + loss = CARBOLITE_TF1_PARAMETERS['heat_loss_W_K']['value'] + power = CARBOLITE_TF1_PARAMETERS['heater_power_W']['value'] + heater_j = 0.0 + decay = _tf1_math.exp(-loss * dt_s / capacity) + if not state['power.enabled']: + new = ambient + (old - ambient) * decay + elif old < target: + equilibrium = ambient + power / loss + crossing_s = -capacity / loss * _tf1_math.log((equilibrium - target) / (equilibrium - old)) + heating_s = min(dt_s, max(0.0, crossing_s)) + new = equilibrium + (old - equilibrium) * _tf1_math.exp(-loss * heating_s / capacity) + heater_j = power * heating_s + if dt_s >= crossing_s: + new = target + heater_j += loss * (target - ambient) * (dt_s - heating_s) + elif old > target: + cooling_s = dt_s if target == ambient else min(dt_s, capacity / loss * _tf1_math.log((old - ambient) / (target - ambient))) + new = ambient + (old - ambient) * _tf1_math.exp(-loss * cooling_s / capacity) + if cooling_s < dt_s: + new = target + heater_j = loss * (target - ambient) * (dt_s - cooling_s) + else: + new = target + heater_j = loss * (target - ambient) * dt_s + change_j = capacity * (new - old) + lost_j = heater_j - change_j + state['thermal.temperature_k'] = new + state['thermal.indicated_temperature_k'] = round(new - 273.15, 1) + 273.15 + state['thermal.heater_energy_j'] += heater_j + state['thermal.heat_loss_energy_j'] += lost_j + state['thermal.stored_energy_j'] = capacity * (new - ambient) + + def step(self, dt_s): + if not _carbolite_tf1_number(dt_s) or not 0 <= dt_s <= 3600: + raise ValueError('dt_s must be finite and within [0, 3600].') + if not dt_s: + return + with self._lock: + failed = False + for sid, inst in self._instances.items(): + before = _tf1_copy.deepcopy(inst['state']) + self._thermal_step(inst, float(dt_s)) + updates = {key: _tf1_copy.deepcopy(value) for key, value in inst['state'].items() if value != before[key]} + if updates: + inst['revision'] += 1 + if self.scene_adapter and updates: + try: + self.scene_adapter(sid, updates) + except Exception: + failed = True + self._scene_faults.append({'instance_id': sid, 'time_s': self.time_s + dt_s, 'code': 'SCENE_SYNC_FAILED'}) + self.time_s += dt_s + if failed: + raise CarboliteTF1SceneSynchronizationError('Process and common clock advanced; one or more scene updates failed.') + + def debug_snapshot(self): + """Trusted-only diagnostics; this is not an agent-readable trace file.""" + with self._lock: + return _tf1_copy.deepcopy({'time_s': self.time_s, 'ambient_temperature_K': self.ambient_temperature_K, + 'instances': self._instances, 'scene_faults': self._scene_faults}) + + +class CarboliteTF1Session: + """Agent-facing protocol adapter with identity assigned by the trusted host.""" + def __init__(self, host, principal_id): + if principal_id not in host._principals: + raise ValueError('Unknown principal.') + self.__host = host + self.__principal_id = principal_id + + def _instance(self, instance_id): + if not isinstance(instance_id, str): + return None + _, scope = self.__host._principals[self.__principal_id] + return self.__host._instances.get(instance_id) if scope is None or instance_id in scope else None + + def _visible(self, slot): + role, _ = self.__host._principals[self.__principal_id] + return slot['visibility'] == 'agent' or role in ('debug', 'evaluator') + + def _envelope(self, instance_id, request_id=None, *, status='succeeded', result=None, observations=None, error=None): + inst = self._instance(instance_id) + return {'protocol_version': '1.0.0', 'instance_id': instance_id if isinstance(instance_id, str) else None, + 'request_id': request_id if isinstance(request_id, str) else None, 'operation_id': None, 'status': status, + 'state_revision': inst['revision'] if inst else None, + 'clock': {'domain': 'simulation', 'time_s': self.__host.time_s}, + 'result': result or {}, 'observations': observations or {}, 'error': error} + + def _error(self, instance_id, code, request_id=None, status='rejected'): + messages = {'UNKNOWN_INSTANCE': 'Instance is unavailable in this session.', 'UNKNOWN_CAPABILITY': 'Capability is unavailable for this asset.', + 'INVALID_ARGUMENT': 'Arguments do not meet the declared schema or limits.', 'PRECONDITION_FAILED': 'Required operating configuration is unavailable.', + 'ACCESS_DENIED': 'Request is outside the session access policy.', 'REQUEST_CONFLICT': 'Request ID was used for a different operation.', + 'UNSUPPORTED': 'No scene backend is registered for this capability.', 'DEVICE_ERROR': 'Scene backend did not complete the command.'} + return self._envelope(instance_id, request_id, status=status, error={'code': code, 'message': messages[code], 'retryable': False, + 'side_effects': 'unknown' if code == 'DEVICE_ERROR' else 'none', 'progress': None}) + + def describe(self, *, asset_type_id=None, instance_id=None): + with self.__host._lock: + if (asset_type_id is None) == (instance_id is None): + return self._error(instance_id, 'INVALID_ARGUMENT') + if instance_id is not None and not self._instance(instance_id): + return self._error(instance_id, 'UNKNOWN_INSTANCE') + if asset_type_id is not None and asset_type_id != CARBOLITE_TF1_ASSET_TYPE: + return self._error(instance_id, 'INVALID_ARGUMENT') + _, scope = self.__host._principals[self.__principal_id] + if scope is not None and not scope: + return self._error(instance_id, 'ACCESS_DENIED') + metadata = carbolite_tf1_metadata() + metadata['instance_id'] = instance_id + metadata['adapter'] = 'basic40_runtime_thermal.CarboliteTF1Session' + metadata['state_slots'] = {sid: slot for sid, slot in metadata['state_slots'].items() if self._visible(slot)} + for name, cap in metadata['capabilities'].items(): + cap['state_effects'] = [effect for effect in cap['state_effects'] if self._visible(CARBOLITE_TF1_STATE_SLOTS[effect['state_id']])] + if name.startswith('scene.') and self.__host.scene_adapter is None: + cap['availability'] = 'unsupported' + return metadata + + def read(self, *, instance_id, state_ids=None): + with self.__host._lock: + inst = self._instance(instance_id) + if not inst: + return self._error(instance_id, 'UNKNOWN_INSTANCE') + slots = CARBOLITE_TF1_STATE_SLOTS + if state_ids is None: + state_ids = [sid for sid, slot in slots.items() if self._visible(slot)] + if not isinstance(state_ids, list) or any(not isinstance(sid, str) for sid in state_ids) or len(set(state_ids)) != len(state_ids): + return self._error(instance_id, 'INVALID_ARGUMENT') + if any(sid not in slots or not self._visible(slots[sid]) for sid in state_ids): + return self._error(instance_id, 'ACCESS_DENIED') + observations = {} + for sid in state_ids: + slot = slots[sid] + value = _tf1_copy.deepcopy(inst['state'][sid]) + observations[sid] = {'value': value, 'unit': slot['unit'], 'quality': 'unavailable' if value is None else 'estimated' if slot['origin'] == 'derived' else 'valid', + 'sample_time_s': self.__host.time_s, 'sample_window_s': [inst['created_at_s'], self.__host.time_s] if slot['sampling']['mode'] == 'integral' else None} + if value is None: + observations[sid]['reason'] = 'No gas transport, pressure solver or physical gas measurement is configured.' + return self._envelope(instance_id, observations=observations) + + def invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if not inst: + return self._error(instance_id, 'UNKNOWN_INSTANCE', request_id) + if not isinstance(request_id, str) or not request_id or len(request_id) > 256 or not isinstance(capability_id, str) or not isinstance(arguments, dict): + return self._error(instance_id, 'INVALID_ARGUMENT', request_id) + try: + digest = _tf1_hashlib.sha256(_tf1_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False, separators=(',', ':')).encode()).hexdigest() + except (ValueError, TypeError, OverflowError): + return self._error(instance_id, 'INVALID_ARGUMENT', request_id) + key = (self.__principal_id, instance_id, request_id) + if key in host._requests: + old_digest, old_response = host._requests[key] + return _tf1_copy.deepcopy(old_response) if old_digest == digest else self._error(instance_id, 'REQUEST_CONFLICT', request_id) + response = self._invoke_checked(instance_id, inst, capability_id, arguments, request_id) + host._requests[key] = (digest, _tf1_copy.deepcopy(response)) + host._logs[self.__principal_id].append({'instance_id': instance_id, 'capability_id': capability_id, 'request_id': request_id, 'response': _tf1_copy.deepcopy(response)}) + return response + + def _invoke_checked(self, instance_id, inst, capability, args, request_id): + host = self.__host + state = inst['state'] + fail = lambda code, status='rejected': self._error(instance_id, code, request_id, status) + metadata = carbolite_tf1_metadata() + if capability not in metadata['capabilities']: + return fail('UNKNOWN_CAPABILITY') + properties = metadata['capabilities'][capability]['input_schema']['properties'] + if set(args) != set(properties): + return fail('INVALID_ARGUMENT') + for name, schema in properties.items(): + value = args[name] + if schema['type'] == 'boolean' and type(value) is not bool: + return fail('INVALID_ARGUMENT') + if schema['type'] == 'string' and (not isinstance(value, str) or value not in schema['enum']): + return fail('INVALID_ARGUMENT') + if schema['type'] == 'number' and (not _carbolite_tf1_number(value) or not schema.get('minimum', -float('inf')) <= value <= schema.get('maximum', float('inf'))): + return fail('INVALID_ARGUMENT') + if capability.startswith('scene.') and host.scene_adapter is None: + return fail('UNSUPPORTED', 'unsupported') + if capability == 'power.set': + if args['enabled'] and state['work_tube.withdrawal_m'] != 0: + return fail('PRECONDITION_FAILED') + updates = {'power.enabled': args['enabled']} + result = {'enabled': args['enabled']} + elif capability == 'thermal.set_temperature': + if args['temperature_K'] < host.ambient_temperature_K: + return fail('INVALID_ARGUMENT') + if not state['power.enabled']: + return fail('PRECONDITION_FAILED') + updates = {'thermal.target_k': float(args['temperature_K'])} + result = {'setpoint_K': float(args['temperature_K'])} + elif capability == 'scene.set_end_seal': + side = args['side'] + sid = 'end_seal.' + side + '.withdrawal_m' + gas_sid = 'gas.' + ('inlet' if side == 'left' else 'outlet') + '.connected' + changing = args['withdrawal_m'] != state[sid] + if changing and (state['power.enabled'] or state[gas_sid] or (state['work_tube.withdrawal_m'] > 0 and args['withdrawal_m'] < 0.10)): + return fail('PRECONDITION_FAILED') + updates = {sid: float(args['withdrawal_m'])} + result = {'side': side, 'withdrawal_m': float(args['withdrawal_m'])} + elif capability == 'scene.set_work_tube': + changing = args['withdrawal_m'] != state['work_tube.withdrawal_m'] + if changing and (state['power.enabled'] or state['end_seal.left.withdrawal_m'] < 0.10 or state['end_seal.right.withdrawal_m'] < 0.10 or state['gas.inlet.connected'] or state['gas.outlet.connected']): + return fail('PRECONDITION_FAILED') + updates = {'work_tube.withdrawal_m': float(args['withdrawal_m'])} + result = {'withdrawal_m': float(args['withdrawal_m'])} + else: + inlet = args['port_id'] == 'gas_inlet' + sid = 'gas.' + ('inlet' if inlet else 'outlet') + '.connected' + seal = 'end_seal.' + ('left' if inlet else 'right') + '.withdrawal_m' + if args['connected'] and not state[sid] and (state['power.enabled'] or state[seal] != 0 or state['work_tube.withdrawal_m'] != 0): + return fail('PRECONDITION_FAILED') + updates = {sid: args['connected']} + result = {'port_id': args['port_id'], 'connected': args['connected']} + changed = {sid: value for sid, value in updates.items() if state[sid] != value} + if host.scene_adapter and changed: + try: + host.scene_adapter(instance_id, _tf1_copy.deepcopy(changed)) + except Exception: + return fail('DEVICE_ERROR', 'failed') + if changed: + state.update(changed) + inst['revision'] += 1 + return self._envelope(instance_id, request_id, result=result) + + def write(self, *, instance_id, state_id, value, request_id): + with self.__host._lock: + if not self._instance(instance_id): + return self._error(instance_id, 'UNKNOWN_INSTANCE', request_id) + slot = CARBOLITE_TF1_STATE_SLOTS.get(state_id) if isinstance(state_id, str) else None + if slot is None or not self._visible(slot) or slot['access'] != 'read_write' or not slot['write_via']: + return self._error(instance_id, 'ACCESS_DENIED', request_id) + route = slot['write_via'] + return self.invoke(instance_id=instance_id, capability_id=route['capability_id'], + arguments={**route['fixed_arguments'], route['parameter']: value}, request_id=request_id) + + def logs(self): + with self.__host._lock: + return _tf1_copy.deepcopy(self.__host._logs[self.__principal_id]) +# END CHEM-186 Carbolite TF1 runtime. + + +# CHEM-012 BINDER VD 56 — appended independently; no batch01/global registry edits. +import copy as _vd56_copy +import math as _vd56_math +from basic40_runtime import LabHost as _VD56BaseHost, LabSession as _VD56BaseSession +from basic40_runtime import _Instance as _VD56Instance, _number as _vd56_number +from basic40_runtime import SceneSynchronizationError as BinderVD56SceneSynchronizationError + +BINDER_VD56_ASSET_ID = "instrument.binder_vd56" +_VD56_SOURCE = "https://www.binder-world.com/int-en/products/drying-ovens/vacuum-drying-chambers/product/vd-56" +_VD56_G = 180.0 / 78.0 +_VD56_C = -_VD56_G * 4800.0 / _vd56_math.log(1.0 - 180.0 / 1400.0) + + +def _vd56_parameter(value, unit, evidence, source): + return {"value": value, "unit": unit, "evidence": evidence, "source": source} + + +BINDER_VD56_PARAMETERS = { + "heater_power_W": _vd56_parameter(1400.0, "W", "public_document", _VD56_SOURCE + "; rated electrical power treated as maximum empty-system heat input"), + "minimum_target_above_ambient_K": _vd56_parameter(9.0, "K", "public_document", "CHEM-012 workbook row 17: ambient +9 deg C"), + "maximum_temperature_K": _vd56_parameter(493.15, "K", "public_document", "CHEM-012 workbook row 17: 220 deg C"), + "thermal_capacity_J_K": _vd56_parameter(_VD56_C, "J/K", "derived_estimate", "C=-G*4800/ln(1-180/1400); whole empty-system effective value calibrated 22->100 deg C in 80 min, not measured component heat capacity"), + "heat_loss_W_K": _vd56_parameter(_VD56_G, "W/K", "derived_estimate", "G=180/(100-22), interpreting 180 Wh/h at 100 deg C as total steady loss; auxiliaries not separately resolved"), + "reference_ambient_temperature_K": _vd56_parameter(295.15, "K", "assumption", "Nominal 22 deg C selected within official empty-chamber test condition +22+/-3 deg C, standard aluminium shelves, chamber pressure <20 mbar"), + "reference_heating_time_s": _vd56_parameter(4800.0, "s", "public_document", _VD56_SOURCE + "; heating-up to 100 deg C: 80 min"), + "maximum_door_angle_rad": _vd56_parameter(_vd56_math.radians(100), "rad", "assumption", "Scene limit; not measured manufacturer travel"), + "door_open_loss_W_K": _vd56_parameter(20.0, "W/K", "assumption", "Uncalibrated extra lumped heat loss at fully open door"), + "door_open_heater_fraction": _vd56_parameter(0.0, "1", "assumption", "Heater derates linearly with door angle to zero at full opening; simulation behavior, not manufacturer interlock"), + "chamber_volume_m3": _vd56_parameter(0.055, "m^3", "public_document", "CHEM-012 workbook: 55 L; gas mass is not solved"), + "isolated_pressure_rise_pa_s": _vd56_parameter(1000.0 / 3600.0, "Pa/s", "public_document", "CHEM-012: 0.01 bar/h interpreted as isolated-chamber pressure rise, not mass leak rate"), + "reference_pressure_pa": _vd56_parameter(5000.0, "Pa", "public_document", "CHEM-012: pressure fluctuation reference 50 mbar absolute"), + "reference_pressure_fluctuation_pa": _vd56_parameter(100.0, "Pa", "public_document", "CHEM-012: +/-1 mbar at 50 mbar, not general absolute accuracy"), + "pressure_proxy_period_s": _vd56_parameter(60.0, "s", "assumption", "Synthetic sine-wave indication period, not manufacturer-specified response"), + "pressure_proxy_activation_tolerance_pa": _vd56_parameter(1.0, "Pa", "assumption", "5000 Pa display ripple activated only within 1 Pa of the explicit external 5000 Pa boundary"), + "vent_time_constant_s": _vd56_parameter(15.0, "s", "assumption", "First-order backfill toward host atmospheric absolute pressure; no gas composition or mass flow"), + "door_pressure_tolerance_pa": _vd56_parameter(100.0, "Pa", "assumption", "Scene opening requires pressure within 100 Pa of host atmosphere; not a hardware safety claim"), + "external_pump_speed_m3_s": _vd56_parameter(None, "m^3/s", "unknown", "No pump included/selected; explicit host boundary and time constant are required, no pump curve inferred"), +} + + +def _vd56_slot(unit, origin, meaning, component, *, value_type="number", visibility="agent", capability=None, parameter=None): + return {"unit": unit, "origin": origin, "visibility": visibility, "access": "read_write" if capability else "read_only", + "write_via": {"capability_id": capability, "parameter": parameter} if capability else None, + "value_schema": {"type": value_type}, "meaning_zh": meaning, "component_ids": [component], + "sampling": {"mode": "instant", "time_domain": "simulation", "window": None}, + "reference_conditions": "Absolute pressure; host atmospheric pressure is the backfill boundary" if unit == "Pa" else None} + + +BINDER_VD56_STATE_SPECS = { + "power.enabled": _vd56_slot("1", "setpoint", "本机加热供电；不控制外接泵", "display", value_type="boolean", capability="power.set", parameter="enabled"), + "thermal.target_k": _vd56_slot("K", "setpoint", "空载系统的温度控制目标", "display", capability="thermal.set_temperature", parameter="temperature_K"), + "thermal.temperature_k": _vd56_slot("K", "process_truth", "空载系统/架面有效温度真值；非真空气体或样品温度", "chamber", visibility="debug"), + "thermal.indicated_temperature_k": _vd56_slot("K", "derived", "按0.1摄氏度网格取整后转换至K的显示代理", "display"), + "door.angle_rad": _vd56_slot("rad", "scene", "门铰链角度，过程状态同步至场景", "door", capability="scene.set_door", parameter="angle_rad"), + "pressure.pressure_pa": _vd56_slot("Pa", "process_truth", "简化外部边界模型的腔内绝对压力真值", "chamber", visibility="debug"), + "pressure.indicated_pressure_pa": _vd56_slot("Pa", "derived", "绝压显示代理；仅5000Pa近稳态叠加合成±100Pa波动，不是全程绝对精度", "display"), + "vacuum.valve_open": _vd56_slot("1", "setpoint", "通向外接真空边界的本机阀门状态", "vacuum_valve", value_type="boolean", capability="vacuum.set_valve", parameter="opened"), + "vent.valve_open": _vd56_slot("1", "setpoint", "回填阀状态，组分未求解", "vent_valve", value_type="boolean", capability="vent.set_valve", parameter="opened"), + "vacuum.external_connected": _vd56_slot("1", "derived", "宿主已配置外接真空边界；本机无内置泵", "vacuum_port", value_type="boolean"), +} +_VD56_CAP_ARGS = { + "power.set": {"enabled": {"type": "boolean"}}, + "thermal.set_temperature": {"temperature_K": {"type": "number", "minimum": 282.15, "maximum": 493.15, "x-unit": "K", "description": "Actual lower bound is host ambient +9 K"}}, + "scene.set_door": {"angle_rad": {"type": "number", "minimum": 0, "maximum": _vd56_math.radians(100), "x-unit": "rad"}}, + "vacuum.set_valve": {"opened": {"type": "boolean"}}, "vent.set_valve": {"opened": {"type": "boolean"}}, +} +_VD56_CAP_RESULTS = {"power.set": ("enabled", "power.enabled"), "thermal.set_temperature": ("setpoint_K", "thermal.target_k"), + "scene.set_door": ("angle_rad", "door.angle_rad"), "vacuum.set_valve": ("opened", "vacuum.valve_open"), "vent.set_valve": ("opened", "vent.valve_open")} +_VD56_COMPONENTS = {"power.set": ["power_inlet", "display", "heater"], "thermal.set_temperature": ["display", "control_buttons", "heater", "chamber", "temperature_probe"], + "scene.set_door": ["door", "door_gasket"], "vacuum.set_valve": ["vacuum_valve", "vacuum_port", "chamber"], "vent.set_valve": ["vent_valve", "inert_gas_port", "chamber"]} +_VD56_SUMMARIES = {"power.set": "设置本机加热供电；外接真空源与机械阀门不随本机断电而改变", "thermal.set_temperature": "仅写入温度目标；实际升降温由宿主step推进", + "scene.set_door": "近环境压力且抽气阀关闭时设置门角；须同步场景适配器", "vacuum.set_valve": "开关通往宿主显式配置的外接真空边界的阀门", + "vent.set_valve": "开关回填阀，后续step使压力趋向宿主环境绝压，无气体组分模型"} +_VD56_PRECONDITIONS = { + "power.set": [], + "thermal.set_temperature": [{"description_zh": "本机开机且温度目标处于环境+9K至493.15K", "state_ids": ["power.enabled"], "enforced_by": "adapter", "check": "power.enabled and ambient_K + 9 <= temperature_K <= 493.15"}], + "scene.set_door": [{"description_zh": "场景适配器存在；开门须抽气阀关闭且腔压与环境差≤100Pa", "state_ids": ["vacuum.valve_open", "pressure.pressure_pa"], "enforced_by": "adapter", "check": "scene_adapter is not None and (angle_rad == 0 or (not vacuum.valve_open and abs(pressure_pa - ambient_pa) <= 100))"}], + "vacuum.set_valve": [{"description_zh": "开启时须已配置外接真空边界、门关闭且回填阀关闭", "state_ids": ["vacuum.external_connected", "door.angle_rad", "vent.valve_open"], "enforced_by": "adapter", "check": "not opened or (external_connected and door.angle_rad == 0 and not vent.valve_open)"}], + "vent.set_valve": [{"description_zh": "开启时抽气阀须关闭；回填边界由宿主环境提供", "state_ids": ["vacuum.valve_open"], "enforced_by": "adapter", "check": "not opened or not vacuum.valve_open"}], +} + + +def export_binder_vd56_metadata(): + """Export static type metadata without instance truth or external evidence.""" + slots = _vd56_copy.deepcopy(BINDER_VD56_STATE_SPECS) + for sid, slot in slots.items(): + slot["read_binding"] = f"BinderVD56Session.read(instance_id=..., state_ids=['{sid}'])" + if slot["origin"] == "derived": + slot["observation_note_zh"] = "quality=estimated的仿真显示代理，非实测传感器值" + caps = {} + examples = {"power.set": {"enabled": True}, "thermal.set_temperature": {"temperature_K": 373.15}, "scene.set_door": {"angle_rad": .5}, "vacuum.set_valve": {"opened": True}, "vent.set_valve": {"opened": True}} + for capability, args in _VD56_CAP_ARGS.items(): + output_key, sid = _VD56_CAP_RESULTS[capability] + out = _vd56_copy.deepcopy(slots[sid]["value_schema"]) + if out["type"] == "number": out["x-unit"] = slots[sid]["unit"] + effects = [{"state_id": sid, "timing": "immediate", "description_zh": _VD56_SUMMARIES[capability]}] + if capability in ("power.set", "thermal.set_temperature", "scene.set_door"): + effects += [{"state_id": key, "timing": "on_step", "description_zh": "宿主时间推进后的空载热响应与显示"} for key in ("thermal.temperature_k", "thermal.indicated_temperature_k")] + if capability in ("scene.set_door", "vacuum.set_valve", "vent.set_valve"): + effects += [{"state_id": key, "timing": "on_step", "description_zh": "宿主时间推进后的腔压与显示；无物料求解"} for key in ("pressure.pressure_pa", "pressure.indicated_pressure_pa")] + pre = _vd56_copy.deepcopy(_VD56_PRECONDITIONS[capability]) + caps[capability] = {"availability": "implemented", "visibility": "agent", "kind": "simulation" if capability.startswith("scene.") else "device_command", "description_zh": _VD56_SUMMARIES[capability], "component_ids": _VD56_COMPONENTS[capability], + "input_schema": {"type": "object", "properties": _vd56_copy.deepcopy(args), "required": list(args), "additionalProperties": False}, + "output_schema": {"type": "object", "properties": {output_key: out}, "required": [output_key], "additionalProperties": False}, + "state_effects": effects, "observes": [sid], "example_arguments": [examples[capability]], "preconditions": pre, "preconditions_zh": [p["description_zh"] for p in pre], + "scene_backend_required": capability.startswith("scene."), "binding": "basic40_runtime_thermal.BinderVD56Session.invoke(instance_id=..., capability_id='" + capability + "', arguments=..., request_id=...)", + "completion_criterion": "Validated command state committed; no process time elapsed", "partial_failure": "Callback failure preserves runtime state; backend effects unknown"} + declared = {"pressure.program": {"availability": "declared", "visibility": "agent", "kind": "configuration", "description_zh": "压力程序未实现；需外接泵与控制系统配置，调用unsupported且不改状态", + "input_schema": {"type": "object", "properties": {"steps": {"type": "array", "minItems": 1, "items": {"type": "object", "properties": {"pressure_Pa": {"type": "number", "exclusiveMinimum": 0, "x-unit": "Pa"}, "duration_s": {"type": "number", "exclusiveMinimum": 0, "x-unit": "s"}}, "required": ["pressure_Pa", "duration_s"], "additionalProperties": False}}}, "required": ["steps"], "additionalProperties": False}, + "output_schema": {"type": "object", "properties": {}, "additionalProperties": False}, "example_arguments": [{"steps": [{"pressure_Pa": 5000, "duration_s": 600}]}], "state_effects": [], "observes": [], "binding": None}} + return {"asset_types": {BINDER_VD56_ASSET_ID: {"catalog_id": "CHEM-012", "model": "BINDER VD 56", "asset_version": "1.0.0", "state_slots": slots, "capabilities": caps, "declared_capabilities": declared, "parameters": _vd56_copy.deepcopy(BINDER_VD56_PARAMETERS)}}, + "host_capabilities": {"sim.step": {"kind": "simulation", "visibility": "trusted_host_only", "binding": "BinderVD56Runtime.step(dt_s)", "scope": "Every registered VD56 instance shares one host clock", "input_schema": {"type": "object", "properties": {"dt_s": {"type": "number", "minimum": 0, "maximum": 3600, "x-unit": "s"}}, "required": ["dt_s"], "additionalProperties": False}}, + "host.configure_external_vacuum": {"kind": "configuration", "visibility": "trusted_host_only", "binding": "BinderVD56Runtime.configure_external_vacuum", "description_zh": "无默认泵；连接时须显式提供绝压边界、时间常数及证据"}, + "host.sync_scene": {"kind": "configuration", "visibility": "trusted_host_only", "binding": "BinderVD56Runtime.sync_scene"}}, "result_schema_scope": "capability.output_schema describes envelope result"} + + +class BinderVD56Runtime(_VD56BaseHost): + """Trusted host; process step, identities, scene and external boundary only. + + Empty-system thermal parameters calibrate the 100 deg C reference; neither + 220 deg C heat-up nor loaded-sample/pressure-dependent heat transfer is + independently calibrated. Agent sessions are not Python/filesystem isolation. + """ + def __init__(self, *, ambient_temperature_K=295.15, ambient_pressure_pa=101325.0, scene_adapter=None): + if not _vd56_number(ambient_pressure_pa) or not 50000 <= ambient_pressure_pa <= 120000: + raise ValueError("Host ambient pressure must be finite in the assumed 50000..120000 Pa range") + super().__init__(ambient_temperature_K=ambient_temperature_K, scene_adapter=scene_adapter) + self.ambient_pressure_pa = float(ambient_pressure_pa) + self._vacuum_boundaries = {} + + def create_instance(self, instance_id, asset_type_id=BINDER_VD56_ASSET_ID): + with self._lock: + if not isinstance(instance_id, str) or not instance_id or instance_id in self._instances or asset_type_id != BINDER_VD56_ASSET_ID: + raise ValueError("Unique nonempty instance ID and VD56 asset type required") + s = {"power.enabled": False, "thermal.target_k": self.ambient_temperature_K + 9.0, "thermal.temperature_k": self.ambient_temperature_K, + "thermal.indicated_temperature_k": round(self.ambient_temperature_K - 273.15, 1) + 273.15, "door.angle_rad": 0.0, + "pressure.pressure_pa": self.ambient_pressure_pa, "pressure.indicated_pressure_pa": round(self.ambient_pressure_pa), + "vacuum.valve_open": False, "vent.valve_open": False, "vacuum.external_connected": False} + if self.scene_adapter: self.scene_adapter(instance_id, _vd56_copy.deepcopy(s)) + self._instances[instance_id] = _VD56Instance(instance_id, asset_type_id, s) + + def session(self, principal_id): + if principal_id not in self._principals: raise ValueError("Principal must first be authenticated and registered by host") + return BinderVD56Session(self, principal_id) + + def _value(self, inst, name): + return BINDER_VD56_PARAMETERS[name]["value"] + + def describe_host(self): + return export_binder_vd56_metadata()["host_capabilities"] + + def configure_external_vacuum(self, instance_id, *, connected, boundary_pressure_pa=None, time_constant_s=None, evidence): + """External asymptotic chamber pressure and time constant, not pump curve. + + The effective boundary includes leak compensation by an active external + pump. No default pump performance exists. Disconnect closes the local + valve. All validation and callback success precede runtime modifications. + """ + with self._lock: + if not isinstance(instance_id, str) or instance_id not in self._instances or type(connected) is not bool or not isinstance(evidence, str) or not evidence.strip(): + raise ValueError("Valid instance, boolean connected and explicit evidence required") + if connected: + if not _vd56_number(boundary_pressure_pa) or not 0 < boundary_pressure_pa < self.ambient_pressure_pa or not _vd56_number(time_constant_s) or not 0 < time_constant_s <= 86400: + raise ValueError("Explicit positive sub-ambient absolute pressure and time constant in (0,86400]s required") + elif boundary_pressure_pa is not None or time_constant_s is not None: + raise ValueError("Disconnected configuration cannot retain active parameters") + inst = self._instances[instance_id] + updates = {"vacuum.external_connected": connected} + if not connected: updates["vacuum.valve_open"] = False + if self.scene_adapter: + try: self.scene_adapter(instance_id, _vd56_copy.deepcopy(updates)) + except Exception: raise RuntimeError("Configuration callback failed; runtime unchanged; backend effects unknown") from None + if connected: self._vacuum_boundaries[instance_id] = {"boundary_pressure_pa": float(boundary_pressure_pa), "time_constant_s": float(time_constant_s), "evidence": evidence} + else: self._vacuum_boundaries.pop(instance_id, None) + inst.state.update(updates) + inst.revision += 1 + + def _pressure_step(self, inst, dt): + s = inst.state + old = s["pressure.pressure_pa"] + boundary = self._vacuum_boundaries.get(inst.instance_id) + if s["door.angle_rad"] > 0 or s["vent.valve_open"]: + pressure = self.ambient_pressure_pa + (old - self.ambient_pressure_pa) * _vd56_math.exp(-dt / self._value(inst, "vent_time_constant_s")) + elif s["vacuum.valve_open"] and s["vacuum.external_connected"]: + pressure = boundary["boundary_pressure_pa"] + (old - boundary["boundary_pressure_pa"]) * _vd56_math.exp(-dt / boundary["time_constant_s"]) + else: + pressure = min(self.ambient_pressure_pa, old + self._value(inst, "isolated_pressure_rise_pa_s") * dt) + s["pressure.pressure_pa"] = pressure + indication = pressure + if s["vacuum.valve_open"] and boundary and boundary["boundary_pressure_pa"] == 5000.0 and abs(pressure - 5000.0) <= 1.0: + # Quantized synthetic steady indication, explicitly not sensor accuracy. + indication = 5000.0 + 100.0 * _vd56_math.sin(2 * _vd56_math.pi * (self.time_s + dt) / self._value(inst, "pressure_proxy_period_s")) + s["pressure.indicated_pressure_pa"] = round(indication) + + def step(self, dt_s): + if not _vd56_number(dt_s) or not 0 <= dt_s <= 3600: raise ValueError("dt_s must be finite in [0,3600]") + if not dt_s: return + with self._lock: + failed = False + for inst in self._instances.values(): + before = _vd56_copy.deepcopy(inst.state) + self._thermal_step(inst, dt_s) + inst.state["thermal.indicated_temperature_k"] = round(inst.state["thermal.temperature_k"] - 273.15, 1) + 273.15 + self._pressure_step(inst, dt_s) + if before != inst.state: inst.revision += 1 + updates = {k: _vd56_copy.deepcopy(v) for k, v in inst.state.items() if before[k] != v} + if self.scene_adapter and updates: + try: self.scene_adapter(inst.instance_id, updates) + except Exception: + failed = True + self._scene_faults.append({"instance_id": inst.instance_id, "time_s": self.time_s + dt_s, "code": "SCENE_SYNC_FAILED"}) + self.time_s += dt_s + if failed: raise BinderVD56SceneSynchronizationError("Process and common time advanced; scene updates failed; inspect trusted diagnostics") + + def debug_snapshot(self): + with self._lock: + result = super().debug_snapshot() + result["external_vacuum_boundaries"] = _vd56_copy.deepcopy(self._vacuum_boundaries) + result["ambient_pressure_pa"] = self.ambient_pressure_pa + return result + + +class BinderVD56Session(_VD56BaseSession): + """Reuse batch01 identity/envelope/dedup, override all asset-spec operations.""" + def __init__(self, host, principal_id): + if principal_id not in host._principals: raise ValueError("Unknown authenticated host principal") + super().__init__(host, principal_id) + self.__vd56_host = host + self.__vd56_principal = principal_id + + def describe(self, *, asset_type_id=None, instance_id=None): + host = self.__vd56_host + with host._lock: + if (asset_type_id is None) == (instance_id is None): return self._error(instance_id, "INVALID_ARGUMENT") + if instance_id is not None: + inst = self._instance(instance_id) + if not inst: return self._error(instance_id, "UNKNOWN_INSTANCE") + asset_type_id = inst.asset_type_id + if asset_type_id != BINDER_VD56_ASSET_ID: return self._error(instance_id, "INVALID_ARGUMENT") + _, scope = host._principals[self.__vd56_principal] + if scope is not None and not scope: return self._error(instance_id, "ACCESS_DENIED") + spec = export_binder_vd56_metadata()["asset_types"][asset_type_id] + caps = {k: {f: _vd56_copy.deepcopy(info[f]) for f in ("input_schema", "output_schema", "description_zh", "preconditions_zh", "availability")} for k, info in spec["capabilities"].items()} + if host.scene_adapter is None: caps["scene.set_door"]["availability"] = "unsupported" + caps.update(_vd56_copy.deepcopy(spec["declared_capabilities"])) + return {"protocol_version": "1.0.0", "asset_type_id": asset_type_id, "asset_version": spec["asset_version"], "instance_id": instance_id, + "catalog_id": spec["catalog_id"], "model": spec["model"], "adapter": "basic40_runtime_thermal.BinderVD56Session", "capabilities": caps, + "state_slots": {k: v for k, v in spec["state_slots"].items() if self._visible(v)}, + "limitations": ["Empty-system/standard-shelf thermal model calibrated only at 100 deg C; not gas/sample temperature, no sample evaporation or drying endpoint.", + "No pump included: explicit external boundary and response time supplied by host. Backfill omits gas composition and mass balance.", + "Estimated indications only; +/-100 Pa synthetic ripple applies solely at a near-steady 5000 Pa boundary, not general sensor accuracy.", + "Mechanical valves and external pump do not follow oven electrical power. No hardware or safety-rated interlock.", + "API filtering is not Python/filesystem isolation; in-memory deduplication does not survive restart."]} + + def read(self, *, instance_id, state_ids=None): + host = self.__vd56_host + with host._lock: + inst = self._instance(instance_id) + if not inst: return self._error(instance_id, "UNKNOWN_INSTANCE") + slots = BINDER_VD56_STATE_SPECS + if state_ids is None: state_ids = [k for k, slot in slots.items() if self._visible(slot)] + if not isinstance(state_ids, list) or any(not isinstance(k, str) for k in state_ids) or len(set(state_ids)) != len(state_ids): return self._error(instance_id, "INVALID_ARGUMENT") + if any(k not in slots or not self._visible(slots[k]) for k in state_ids): return self._error(instance_id, "ACCESS_DENIED") + observations = {k: {"value": _vd56_copy.deepcopy(inst.state[k]), "unit": slots[k]["unit"], "quality": "estimated" if slots[k]["origin"] == "derived" else "valid", "sample_time_s": host.time_s, "sample_window_s": None} for k in state_ids} + return self._envelope(instance_id, observations=observations) + + def _invoke_checked(self, inst, capability, args, request): + host, s = self.__vd56_host, inst.state + fail = lambda code, status="rejected": self._error(inst.instance_id, code, request, status) + if capability == "pressure.program": return fail("UNSUPPORTED", "unsupported") + if capability not in _VD56_CAP_ARGS: return fail("UNKNOWN_CAPABILITY") + expected = _VD56_CAP_ARGS[capability] + if set(args) != set(expected): return fail("INVALID_ARGUMENT") + for k, schema in expected.items(): + if (schema["type"] == "boolean" and type(args[k]) is not bool) or (schema["type"] == "number" and not _vd56_number(args[k])): return fail("INVALID_ARGUMENT") + value = next(iter(args.values())) + if capability == "thermal.set_temperature": + if not host.ambient_temperature_K + 9 <= value <= 493.15: return fail("INVALID_ARGUMENT") + if not s["power.enabled"]: return fail("PRECONDITION_FAILED") + elif capability == "scene.set_door": + if not 0 <= value <= _vd56_math.radians(100): return fail("INVALID_ARGUMENT") + if value > 0 and (s["vacuum.valve_open"] or abs(s["pressure.pressure_pa"] - host.ambient_pressure_pa) > 100): return fail("PRECONDITION_FAILED") + if host.scene_adapter is None: return fail("UNSUPPORTED", "unsupported") + elif capability == "vacuum.set_valve" and value: + if not s["vacuum.external_connected"] or s["door.angle_rad"] != 0 or s["vent.valve_open"]: return fail("PRECONDITION_FAILED") + elif capability == "vent.set_valve" and value and s["vacuum.valve_open"]: return fail("PRECONDITION_FAILED") + output_key, sid = _VD56_CAP_RESULTS[capability] + updates = {sid: value} + if host.scene_adapter: + try: host.scene_adapter(inst.instance_id, _vd56_copy.deepcopy(updates)) + except Exception: return fail("DEVICE_ERROR", "failed") + s.update(updates) + inst.revision += 1 + return self._envelope(inst.instance_id, request, result={output_key: value}) + + def write(self, *, instance_id, state_id, value, request_id): + with self.__vd56_host._lock: + if not self._instance(instance_id): return self._error(instance_id, "UNKNOWN_INSTANCE", request_id) + slot = BINDER_VD56_STATE_SPECS.get(state_id) if isinstance(state_id, str) else None + if not slot or not self._visible(slot) or slot["access"] != "read_write": return self._error(instance_id, "ACCESS_DENIED", request_id) + route = slot["write_via"] + return self.invoke(instance_id=instance_id, capability_id=route["capability_id"], arguments={route["parameter"]: value}, request_id=request_id) + + +def validate_binder_vd56_runtime(output=None): + """Execute VD56-only tests; artifact has synthetic results, no live truth.""" + import importlib.util as _vd56_util + import io as _vd56_io + import json as _vd56_json + import platform as _vd56_platform + import sys as _vd56_sys + import unittest as _vd56_unittest + from datetime import datetime as _vd56_datetime, timezone as _vd56_timezone + from pathlib import Path as _VD56Path + path = _VD56Path(__file__).resolve().parents[1] / "tests" / "test_basic40_thermal.py" + spec = _vd56_util.spec_from_file_location("test_basic40_thermal", path) + module = _vd56_util.module_from_spec(spec) + spec.loader.exec_module(module) + records = [] + class _VD56RecordingResult(_vd56_unittest.TextTestResult): + def addSuccess(self, test): + super().addSuccess(test) + records.append({"id": test._testMethodName, "status": "passed", "layer": "process"}) + def addFailure(self, test, error): + super().addFailure(test, error) + records.append({"id": test._testMethodName, "status": "failed", "layer": "process"}) + def addError(self, test, error): + super().addError(test, error) + records.append({"id": test._testMethodName, "status": "failed", "layer": "process"}) + suite = _vd56_unittest.defaultTestLoader.loadTestsFromTestCase(module.BinderVD56RuntimeTests) + stream = _vd56_io.StringIO() + result = _vd56_unittest.TextTestRunner(stream=stream, verbosity=2, resultclass=_VD56RecordingResult).run(suite) + mapping = {"test_vd56_power_leaves_external_pump_and_valves_independent": ["power.set"], "test_vd56_temperature_target_only_and_80_minute_calibration": ["thermal.set_temperature"], + "test_vd56_door_requires_backfill_and_scene_sync": ["scene.set_door"], "test_vd56_vacuum_requires_connection_and_atomic_prechecks": ["vacuum.set_valve"], + "test_vd56_isolated_leak_and_backfill_are_time_driven": ["vent.set_valve"], "test_vd56_pressure_program_declared_unsupported": ["pressure.program"]} + host_checks = {"test_vd56_agent_truth_identity_and_log_isolation", "test_vd56_host_configuration_prevalidates_every_field", + "test_vd56_invalid_time_and_zero_step_leave_state_unchanged", "test_vd56_read_describe_logs_do_not_advance_or_mutate", + "test_vd56_real_result_and_observation_schemas", "test_vd56_request_replay_and_conflict_preserve_state", "test_vd56_write_routes_and_cannot_change_truth"} + for record in list(records): + if record["id"] in host_checks: record["layer"] = "host" + for cap in mapping.get(record["id"], []): records.append({**record, "capability_id": cap}) + if record["id"] == "test_vd56_real_result_and_observation_schemas": + # This test actually invokes every implemented capability and checks + # its real result envelope against the exported schema. + for cap in _VD56_CAP_ARGS: records.append({**record, "capability_id": cap}) + report = {"catalog_id": "CHEM-012", "asset_type_id": BINDER_VD56_ASSET_ID, "checked_at": _vd56_datetime.now(_vd56_timezone.utc).isoformat(), + "method": "Python unittest; synthetic empty-oven and explicit external-pressure fixtures", "environment": {"python": _vd56_sys.version, "platform": _vd56_platform.platform(), "scene_backend": "recording callback; no Blender run in this suite"}, + "status": "passed" if result.wasSuccessful() else "failed", "tests_run": result.testsRun, "checks": records, "log": stream.getvalue(), + "not_run": ["evaluated Blender poses", "contact dynamics", "real hardware", "robot", "sample evaporation", "gas mass/species conservation"], "privacy": "Synthetic test identifiers/results only; no live instance values or host evidence strings"} + if output is not None: + target = _VD56Path(output) + target.parent.mkdir(parents=True, exist_ok=True) + target.write_text(_vd56_json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + return report + +# BEGIN CHEM-187 JULABO CORIO CD-200F. Independent append-only runtime. +import copy as _julabo_copy +import hashlib as _julabo_hashlib +import json as _julabo_json +import math as _julabo_math +import threading as _julabo_threading + +JULABO_CORIO_CD200F_TYPE = 'instrument.julabo_corio_cd200f' +JULABO_CORIO_CD200F_SOURCE = 'https://www.julabo.com/en/products/refrigerated-circulators/refrigerated-heating-circulators/corio-cd-200f' +JULABO_CORIO_CD200F_COOLING_POINTS = ((253.15, 60.0), (263.15, 130.0), (273.15, 170.0), (293.15, 220.0)) +JULABO_CORIO_CD200F_MAX_FLOW = 15.0 / 60000.0 +JULABO_CORIO_CD200F_MAX_PRESSURE = 35000.0 + + +def _julabo_number(value): + try: + return type(value) in (int, float) and _julabo_math.isfinite(value) + except (OverflowError, TypeError): + return False + + +def _julabo_schema(unit, low=None, high=None, nullable=False): + result = {'type': 'number', 'x-unit': unit} + if low is not None: result['minimum'] = low + if high is not None: result['maximum'] = high + return {'anyOf': [result, {'type': 'null'}]} if nullable else result + + +def _julabo_object(properties): + return {'type': 'object', 'properties': properties, 'required': list(properties), 'additionalProperties': False} + + +def _julabo_slot(unit, origin, component, meaning, *, nullable=False, boolean=False, route=None, integral=False): + return {'unit': unit, 'origin': origin, 'visibility': 'debug' if origin == 'process_truth' else 'agent', + 'access': 'read_write' if route else 'read_only', 'write_via': route, + 'value_schema': {'type': 'boolean'} if boolean else _julabo_schema(unit, nullable=nullable), + 'component_ids': [component], 'meaning_zh': meaning, + 'sampling': {'mode': 'integral' if integral else 'instant', 'time_domain': 'simulation', 'window': 'Since latest trusted bath configuration' if integral else None}, + 'reference_conditions': 'Pump differential pressure; not absolute pressure' if unit == 'Pa' else 'Actual liquid volume flow at host-configured operating point' if unit == 'm^3/s' else 'Bath cover relative to base; positive q maps to Blender rotation_x=-q' if unit == 'rad' else None} + + +def export_julabo_corio_cd200f_metadata(): + """Static contract metadata; no instance configuration or privileged truth.""" + def route(capability, parameter): return {'capability_id': capability, 'parameter': parameter, 'fixed_arguments': {}} + slots = { + 'power.enabled': _julabo_slot('1', 'setpoint', 'controller', '本机供电许可', boolean=True, route=route('power.set', 'enabled')), + 'thermal.target_k': _julabo_slot('K', 'setpoint', 'controller', '只写入温度目标；实际温度由宿主时间推进', route=route('thermal.set_temperature', 'temperature_K')), + 'thermal.temperature_k': _julabo_slot('K', 'process_truth', 'bath_vessel', '均匀混合浴液有效温度；未配置热模型为null', nullable=True), + 'thermal.indicated_temperature_k': _julabo_slot('K', 'derived', 'display', '0.01°C网格取整的理想温度显示代理；非传感器精度模型', nullable=True), + 'thermal.model_configured': _julabo_slot('1', 'derived', 'bath_vessel', '宿主已显式配置有效热容和热损失', boolean=True), + 'thermal.cooling_curve_supported': _julabo_slot('1', 'derived', 'refrigeration_unit', '温度位于有据制冷功率插值域且环境为20°C；仅乙醇参考等效模型', boolean=True), + 'bath_lid.angle_rad': _julabo_slot('rad', 'scene', 'bath_lid', '浴盖角度；宿主同步至bath_lid_joint负X轴', route=route('scene.set_bath_lid', 'angle_rad')), + 'circulation.running': _julabo_slot('1', 'setpoint', 'circulation_pump', '模拟循环许可；不代表已解算外部回路流动', boolean=True, route=route('circulation.set_running', 'running')), + 'circulation.external_connected': _julabo_slot('1', 'derived', 'pump_supply', '宿主已配置外部流量/压差边界；并非真实管线连接检测', boolean=True), + 'circulation.flow_rate_m3_s': _julabo_slot('m^3/s', 'derived', 'circulation_pump', '宿主给定运行点的实际体积流量；未配置运行点为null，停止为0；非流量传感器', nullable=True), + 'circulation.pressure_rise_pa': _julabo_slot('Pa', 'derived', 'circulation_pump', '宿主给定运行点的泵压差；未配置运行点为null，停止为0；非压力传感器', nullable=True), + } + for name, meaning in (('heater_energy_j', '累计加热输入'), ('cooling_energy_j', '累计制冷移除热量'), ('environment_energy_j', '累计向环境净放热，可为负'), ('stored_energy_change_j', '相对本次配置初态的浴液储能变化')): + slots['thermal.' + name] = _julabo_slot('J', 'process_truth', 'bath_vessel', meaning, integral=True) + for sid, slot in slots.items(): + slot['read_binding'] = f"JulaboCorioCD200FSession.read(instance_id=..., state_ids=['{sid}'])" + if slot['origin'] == 'derived': slot['observation_note_zh'] = '仿真派生量quality=estimated，缺测quality=unavailable；不声称实测传感器数据。' + definitions = { + 'power.set': ({'enabled': {'type': 'boolean'}}, 'enabled', 'power.enabled', {'enabled': True}, ['controller', 'heater', 'refrigeration_unit', 'circulation_pump'], '设置供电；断电停止循环，保留温度与累计热量', ['power.enabled', 'circulation.running', 'circulation.flow_rate_m3_s', 'circulation.pressure_rise_pa']), + 'thermal.set_temperature': ({'temperature_K': _julabo_schema('K', 253.15, 423.15)}, 'setpoint_K', 'thermal.target_k', {'temperature_K': 313.15}, ['controller', 'display', 'heater', 'refrigeration_unit', 'bath_vessel'], '只写温度目标，需本机已上电；已配置流体时还必须处于其明确适用温区', ['thermal.target_k']), + 'circulation.set_running': ({'running': {'type': 'boolean'}}, 'running', 'circulation.running', {'running': True}, ['circulation_pump', 'pump_supply', 'pump_return'], '设置模拟循环许可；开启须已供电且浴热模型已配置；开启后才允许热输���', ['circulation.running', 'circulation.flow_rate_m3_s', 'circulation.pressure_rise_pa']), + 'scene.set_bath_lid': ({'angle_rad': _julabo_schema('rad', 0, _julabo_math.pi / 2)}, 'angle_rad', 'bath_lid.angle_rad', {'angle_rad': .5}, ['bath_lid'], '设置浴盖角度；须有同步场景回调，正角度映射负X旋转；不是机器人执行', ['bath_lid.angle_rad']), + } + caps = {} + for name, (args, output, sid, example, components, meaning, immediate) in definitions.items(): + pre = [] + if name == 'thermal.set_temperature': pre = [{'description_zh': '本机上电且在已配置流体适用温区内', 'state_ids': ['power.enabled', 'thermal.model_configured'], 'enforced_by': 'adapter', 'check': 'power.enabled and (not configured or fluid_min_K <= temperature_K <= fluid_max_K)'}] + if name == 'circulation.set_running': pre = [{'description_zh': '开启需要上电与显式浴热模型；这是模拟前提，不宣称硬件液位互锁', 'state_ids': ['power.enabled', 'thermal.model_configured'], 'enforced_by': 'adapter', 'check': 'not running or (power.enabled and thermal.model_configured)'}] + if name.startswith('scene.'): pre = [{'description_zh': '同步场景适配器存在', 'state_ids': [], 'enforced_by': 'adapter', 'check': 'scene_adapter is not None'}] + effects = [{'state_id': key, 'timing': 'immediate', 'description_zh': meaning} for key in immediate] + effects += [{'state_id': key, 'timing': 'on_step', 'description_zh': '宿主推进后的有限功率热响应和累计能量；未配置时温度保持null'} for key in slots if key.startswith('thermal.') and key not in ('thermal.target_k', 'thermal.model_configured')] + caps[name] = {'availability': 'implemented', 'visibility': 'agent', 'kind': 'simulation' if name.startswith('scene.') else 'device_command', + 'description_zh': meaning, 'component_ids': components, 'input_schema': _julabo_object(args), 'output_schema': _julabo_object({output: _julabo_copy.deepcopy(slots[sid]['value_schema'])}), + 'example_arguments': [example], 'observes': [sid], 'state_effects': effects, 'preconditions': pre, + 'binding': f"basic40_runtime_thermal.JulaboCorioCD200FSession.invoke(instance_id=..., capability_id='{name}', arguments=..., request_id=...)", + 'scene_backend_required': name.startswith('scene.'), 'completion_criterion_zh': '同步返回确认设定完成；温度变化及累计热量由随后host.step推进，read不推进时间。'} + def p(value, unit, evidence, source): return {'value': value, 'unit': unit, 'evidence': evidence, 'source': source} + params = { + 'heater_power_W': p(2000.0, 'W', 'public_document', JULABO_CORIO_CD200F_SOURCE + '; 9012701.N1.03 heating capacity'), + 'minimum_temperature_K': p(253.15, 'K', 'public_document', JULABO_CORIO_CD200F_SOURCE), + 'maximum_temperature_K': p(423.15, 'K', 'public_document', JULABO_CORIO_CD200F_SOURCE), + 'cooling_capacity_20C_W': p(220.0, 'W', 'public_document', 'Ethanol; ambient 20°C; DIN12876'), + 'cooling_capacity_0C_W': p(170.0, 'W', 'public_document', 'Ethanol; ambient 20°C; DIN12876'), + 'cooling_capacity_minus10C_W': p(130.0, 'W', 'public_document', 'Ethanol; ambient 20°C; DIN12876'), + 'cooling_capacity_minus20C_W': p(60.0, 'W', 'public_document', 'Ethanol; ambient 20°C; DIN12876'), + 'maximum_flow_rate_m3_s': p(JULABO_CORIO_CD200F_MAX_FLOW, 'm^3/s', 'public_document', '15 L/min; independent maximum, not simultaneous 0.35 bar'), + 'maximum_pressure_rise_Pa': p(35000.0, 'Pa', 'public_document', '0.35 bar; independent maximum, not simultaneous 15 L/min'), + 'thermal_capacity_J_K': p(None, 'J/K', 'unknown', 'No default. Host must explicitly supply effective C or fluid mass*cp; whole-instrument 26 kg is not used.'), + 'heat_loss_W_K': p(None, 'W/K', 'unknown', 'No default. Host must explicitly supply UA; graph slope alone does not identify both C and UA.'), + 'lid_open_loss_W_K': p(None, 'W/K', 'unknown', 'No default. Explicit host assumption, not measured lid heat transfer.'), + 'cooling_capacity_above20C_W': p(None, 'W', 'unknown', 'No extrapolation: refrigeration is inactive above supported curve domain and status reports unsupported; passive environmental exchange remains.'), + 'maximum_lid_angle_rad': p(_julabo_math.pi / 2, 'rad', 'assumption', 'Illustrative scene joint travel; not a manufacturer actuator limit'), + 'graph_inferred_heating_capacity_J_K': p(7200.0, 'J/K', 'derived_estimate', 'Thermal medium: C=2000W*180s/50K from approximate 100→150°C graph segment; assumes UA=0 and full heater input; not default, not component heat capacity'), + } + host = { + 'sim.step': {'kind': 'simulation', 'visibility': 'trusted_host_only', 'input_schema': _julabo_object({'dt_s': _julabo_schema('s', 0, 3600)}), 'binding': 'JulaboCorioCD200FRuntime.step(dt_s)', 'partial_failure': 'Process and shared clock commit before scene callbacks; SceneSynchronizationError reports possible partial scene effects.'}, + 'sim.configure_bath_model': {'kind': 'configuration', 'visibility': 'trusted_host_only', 'binding': 'JulaboCorioCD200FRuntime.configure_bath_model(instance_id, *, effective_heat_capacity_J_K, heat_loss_W_K, lid_open_loss_W_K, initial_temperature_K, minimum_temperature_K, maximum_temperature_K, evidence)', 'description_zh': '仅断电时初始化显式热模型并重置该配置的累计热量；不是加液或重置真实仪器。'}, + 'sim.configure_bath_fluid': {'kind': 'configuration', 'visibility': 'trusted_host_only', 'binding': 'JulaboCorioCD200FRuntime.configure_bath_fluid(instance_id, *, mass_kg, specific_heat_J_kg_K, heat_loss_W_K, lid_open_loss_W_K, initial_temperature_K, minimum_temperature_K, maximum_temperature_K, evidence)', 'description_zh': 'C=m*cp，仅浴液单节点假设；未包含未知槽体/样品热容。'}, + 'sim.configure_circulation_boundary': {'kind': 'configuration', 'visibility': 'trusted_host_only', 'binding': 'JulaboCorioCD200FRuntime.configure_circulation_boundary(instance_id, *, connected, flow_rate_m3_s=None, pressure_rise_Pa=None, evidence)', 'description_zh': '显式外部运行点；无默认泵曲线、回路阻力或物料转移解算；拒绝同时取两个厂家极值。'}, + } + return {'asset_types': {JULABO_CORIO_CD200F_TYPE: {'catalog_id': 'CHEM-187', 'model': 'JULABO CORIO CD-200F 9012701.N1.03', 'asset_version': '1.0.0', 'state_slots': slots, 'capabilities': caps, 'parameters': params, 'declared_capabilities': {}}}, + 'host_capabilities': host, 'trusted_scene_callback': 'scene_adapter(instance_id, updates): synchronous SI; bath_lid.angle_rad maps to bath_lid_joint about -X; no callback means scene command unsupported', + 'result_schema_scope': 'capability.output_schema validates response.result only', + 'limitations': ['Single well-mixed node; no fluid phase changes, evaporation, sample chemistry, fluid mass transfer, or external thermal circuit.', 'Cooling power interpolates manufacturer ethanol reference points only at 20°C ambient; applying to another fluid is an explicit host reference-model assumption, not validated performance.', 'Above20°C refrigeration capacity is unknown and not extrapolated; passive heat loss and heating remain modeled.', 'UA and C are explicitly configured assumptions/estimates; no fitted manufacturer defaults.', 'API access filtering is not a Python-process or filesystem security sandbox. Host and debug files must be inaccessible to untrusted agents.', 'In-memory request deduplication only; no restart persistence, hardware control or robot execution.']} + + +class JulaboCorioCD200FRuntime: + """Trusted host; give sessions, not this object or debug files, to agents.""" + def __init__(self, *, ambient_temperature_K=293.15, scene_adapter=None): + if not _julabo_number(ambient_temperature_K) or not 273.15 <= ambient_temperature_K <= 313.15: + raise ValueError('Host ambient must be finite in assumed 273.15..313.15 K range') + self.ambient_temperature_K = float(ambient_temperature_K) + self.scene_adapter = scene_adapter + self.time_s = 0.0 + self._instances, self._requests, self._scene_faults = {}, {}, [] + self._principals = {'__julabo_public_agent__': ('agent', None)} + self._logs = {'__julabo_public_agent__': []} + self._lock = _julabo_threading.RLock() + self._metadata = export_julabo_corio_cd200f_metadata() + self._agent = JulaboCorioCD200FSession(self, '__julabo_public_agent__') + + def create_instance(self, instance_id, asset_type_id=JULABO_CORIO_CD200F_TYPE): + with self._lock: + if not isinstance(instance_id, str) or not instance_id or instance_id in self._instances or asset_type_id != JULABO_CORIO_CD200F_TYPE: + raise ValueError('Unique nonempty ID and declared JULABO type required') + state = {'power.enabled': False, 'thermal.target_k': self.ambient_temperature_K, 'thermal.temperature_k': None, 'thermal.indicated_temperature_k': None, + 'thermal.model_configured': False, 'thermal.cooling_curve_supported': False, 'bath_lid.angle_rad': 0.0, 'circulation.running': False, 'circulation.external_connected': False, + 'circulation.flow_rate_m3_s': 0.0, 'circulation.pressure_rise_pa': 0.0, + 'thermal.heater_energy_j': 0.0, 'thermal.cooling_energy_j': 0.0, 'thermal.environment_energy_j': 0.0, 'thermal.stored_energy_change_j': 0.0} + self._push_before_commit(instance_id, state) + self._instances[instance_id] = {'state': state, 'revision': 0, 'thermal_configuration': None, 'circulation_boundary': None, 'energy_start_s': self.time_s} + + def _push_before_commit(self, instance_id, updates): + if self.scene_adapter: + try: self.scene_adapter(instance_id, _julabo_copy.deepcopy(updates)) + except Exception: raise RuntimeError('Scene callback failed; process unchanged; backend effects unknown') from None + + def register_principal(self, principal_id, *, visibility, instance_ids=None): + with self._lock: + if not isinstance(principal_id, str) or not principal_id or principal_id in self._principals or visibility not in ('agent', 'debug', 'evaluator'): + raise ValueError('Host must register a unique identity with known visibility') + if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(x, str) for x in instance_ids)): + raise ValueError('Instance scope must be a sequence of IDs') + scope = None if instance_ids is None else frozenset(instance_ids) + if scope is not None and not scope <= self._instances.keys(): raise ValueError('Unknown instance in scope') + self._principals[principal_id], self._logs[principal_id] = (visibility, scope), [] + + def session(self, principal_id): + if not isinstance(principal_id, str) or principal_id not in self._principals: raise ValueError('Host identity required') + return JulaboCorioCD200FSession(self, principal_id) + + def describe(self, **kwargs): return self._agent.describe(**kwargs) + def read(self, **kwargs): return self._agent.read(**kwargs) + def invoke(self, **kwargs): return self._agent.invoke(**kwargs) + def write(self, **kwargs): return self._agent.write(**kwargs) + def describe_host(self): return _julabo_copy.deepcopy(self._metadata['host_capabilities']) + + def debug_snapshot(self): + with self._lock: return _julabo_copy.deepcopy({'time_s': self.time_s, 'instances': self._instances, 'scene_faults': self._scene_faults}) + + def configure_bath_model(self, instance_id, *, effective_heat_capacity_J_K, heat_loss_W_K, lid_open_loss_W_K, initial_temperature_K, minimum_temperature_K, maximum_temperature_K, evidence): + """Explicit host initialization; no material transfer or hardware reset.""" + with self._lock: + values = (effective_heat_capacity_J_K, heat_loss_W_K, lid_open_loss_W_K, initial_temperature_K, minimum_temperature_K, maximum_temperature_K) + if not isinstance(instance_id, str) or instance_id not in self._instances or not all(_julabo_number(x) for x in values) or not isinstance(evidence, str) or not evidence.strip(): + raise ValueError('Known instance, finite explicit parameters and evidence required') + if effective_heat_capacity_J_K <= 0 or heat_loss_W_K < 0 or lid_open_loss_W_K < 0 or not _julabo_number(heat_loss_W_K + lid_open_loss_W_K): raise ValueError('Positive C and nonnegative finite loss required') + if not 253.15 <= minimum_temperature_K <= initial_temperature_K <= maximum_temperature_K <= 423.15 or minimum_temperature_K == maximum_temperature_K: raise ValueError('Explicit valid fluid range and initial temperature required') + if not minimum_temperature_K <= self.ambient_temperature_K <= maximum_temperature_K: raise ValueError('Fluid range must include ambient for passive cooling model') + inst = self._instances[instance_id] + if inst['state']['power.enabled'] or inst['state']['circulation.running']: raise ValueError('Configure only when powered off and stopped') + cfg = dict(zip(('effective_heat_capacity_J_K', 'heat_loss_W_K', 'lid_open_loss_W_K', 'initial_temperature_K', 'minimum_temperature_K', 'maximum_temperature_K'), map(float, values))) + cfg['evidence'] = evidence + state = _julabo_copy.deepcopy(inst['state']) + state.update({'thermal.target_k': float(initial_temperature_K), 'thermal.temperature_k': float(initial_temperature_K), 'thermal.indicated_temperature_k': self._indicate(initial_temperature_K), 'thermal.model_configured': True, 'thermal.cooling_curve_supported': self._cooling_supported(initial_temperature_K)}) + for key in state: + if key.endswith('_energy_j') or key == 'thermal.stored_energy_change_j': state[key] = 0.0 + self._push_before_commit(instance_id, state) + inst.update(state=state, thermal_configuration=cfg, energy_start_s=self.time_s, revision=inst['revision'] + 1) + + def configure_bath_fluid(self, instance_id, *, mass_kg, specific_heat_J_kg_K, **kwargs): + with self._lock: + if not _julabo_number(mass_kg) or not _julabo_number(specific_heat_J_kg_K) or mass_kg <= 0 or specific_heat_J_kg_K <= 0 or not _julabo_number(mass_kg * specific_heat_J_kg_K): raise ValueError('Explicit positive finite liquid mass and heat capacity required') + self.configure_bath_model(instance_id, effective_heat_capacity_J_K=mass_kg * specific_heat_J_kg_K, **kwargs) + self._instances[instance_id]['thermal_configuration'].update(mass_kg=float(mass_kg), specific_heat_J_kg_K=float(specific_heat_J_kg_K), capacity_model='C=m*cp; fluid only, no inferred instrument/component mass') + + def configure_circulation_boundary(self, instance_id, *, connected, flow_rate_m3_s=None, pressure_rise_Pa=None, evidence): + with self._lock: + if not isinstance(instance_id, str) or instance_id not in self._instances or type(connected) is not bool or not isinstance(evidence, str) or not evidence.strip(): raise ValueError('Valid instance, boolean connection and explicit evidence required') + if connected: + if not _julabo_number(flow_rate_m3_s) or not 0 <= flow_rate_m3_s <= JULABO_CORIO_CD200F_MAX_FLOW or not _julabo_number(pressure_rise_Pa) or not 0 <= pressure_rise_Pa <= 35000: raise ValueError('Operating point exceeds separate manufacturer limits') + if flow_rate_m3_s == JULABO_CORIO_CD200F_MAX_FLOW and pressure_rise_Pa == 35000: raise ValueError('Maximum flow and maximum pressure are not simultaneous') + boundary = {'flow_rate_m3_s': float(flow_rate_m3_s), 'pressure_rise_Pa': float(pressure_rise_Pa), 'evidence': evidence} + else: + if flow_rate_m3_s is not None or pressure_rise_Pa is not None: raise ValueError('Disconnected boundary cannot retain operating point') + boundary = None + inst = self._instances[instance_id] + if inst['state']['circulation.running']: raise ValueError('Stop circulation before reconfiguring external boundary') + self._push_before_commit(instance_id, {'circulation.external_connected': connected}) + inst['circulation_boundary'] = boundary + inst['state']['circulation.external_connected'] = connected + inst['revision'] += 1 + + @staticmethod + def _indicate(temperature): return round(temperature - 273.15, 2) + 273.15 + + def _cooling_supported(self, temperature): + return temperature is not None and 253.15 <= temperature <= 293.15 and self.ambient_temperature_K == 293.15 + + def _cooling_line(self, temperature, direction=-1): + if not self._cooling_supported(temperature): return (0.0, 0.0) + points = JULABO_CORIO_CD200F_COOLING_POINTS + for (lo, plo), (hi, phi) in zip(points, points[1:]): + if lo <= temperature <= hi and not (temperature == hi and direction > 0 and hi != points[-1][0]): + slope = (phi - plo) / (hi - lo) + return plo - slope * lo, slope + return (0.0, 0.0) + + def _step_thermal(self, inst, dt): + state, cfg = inst['state'], inst['thermal_configuration'] + if cfg is None: return + capacity = cfg['effective_heat_capacity_J_K'] + loss = cfg['heat_loss_W_K'] + cfg['lid_open_loss_W_K'] * state['bath_lid.angle_rad'] / (_julabo_math.pi / 2) + ambient, target, temperature = self.ambient_temperature_K, state['thermal.target_k'], state['thermal.temperature_k'] + enabled = state['power.enabled'] and state['circulation.running'] + remaining, heating, cooling, environment = float(dt), 0.0, 0.0, 0.0 + # Exact affine ODE on each manufacturer cooling segment; split at targets/knots. + while remaining > 1e-10: + cool_a, cool_b = self._cooling_line(temperature) + required = loss * (temperature - ambient) + if not enabled: u_a, u_b = 0.0, 0.0 + elif temperature < target - 1e-10: u_a, u_b = 2000.0, 0.0 + elif temperature > target + 1e-10: u_a, u_b = -cool_a, -cool_b + else: + available = max(0.0, cool_a + cool_b * temperature) + u_a, u_b = min(2000.0, max(-available, required)), 0.0 + a, b = (u_a + loss * ambient) / capacity, (u_b - loss) / capacity + rate = a + b * temperature + if rate > 0 and enabled and temperature > target + 1e-10: + cool_a, cool_b = self._cooling_line(temperature, 1) + u_a, u_b = -cool_a, -cool_b + a, b = (u_a + loss * ambient) / capacity, (u_b - loss) / capacity + rate = a + b * temperature + duration = remaining + candidates = [target, cfg['minimum_temperature_K'], cfg['maximum_temperature_K']] + candidates += [point[0] for point in JULABO_CORIO_CD200F_COOLING_POINTS] + endpoint = None + if abs(rate) > 1e-13: + for bound in candidates: + if (bound - temperature) * rate <= 1e-10: continue + if abs(b) < 1e-18: crossing = (bound - temperature) / rate + else: + ratio = b * (bound - temperature) / rate + if ratio <= -1: continue + crossing = _julabo_math.log1p(ratio) / b + if 1e-10 < crossing <= duration: + duration, endpoint = crossing, bound + if abs(b) < 1e-18: + next_temperature = temperature + rate * duration + integrated_t = temperature * duration + .5 * rate * duration * duration + else: + growth = _julabo_math.expm1(b * duration) + next_temperature = temperature + rate * growth / b + integrated_t = temperature * duration + rate * (growth / b - duration) / b + if endpoint is not None: next_temperature = endpoint + energy_input = u_a * duration + u_b * integrated_t + heating += max(0.0, energy_input) + cooling += max(0.0, -energy_input) + environment += loss * (integrated_t - ambient * duration) + remaining -= duration + temperature = next_temperature + state['thermal.temperature_k'] = temperature + state['thermal.indicated_temperature_k'] = self._indicate(temperature) + state['thermal.cooling_curve_supported'] = self._cooling_supported(temperature) + state['thermal.heater_energy_j'] += heating + state['thermal.cooling_energy_j'] += cooling + state['thermal.environment_energy_j'] += environment + state['thermal.stored_energy_change_j'] = capacity * (temperature - cfg['initial_temperature_K']) + + def step(self, dt_s): + if not _julabo_number(dt_s) or not 0 <= dt_s <= 3600: raise ValueError('dt_s must be finite in [0,3600]') + if not dt_s: return + with self._lock: + candidates = _julabo_copy.deepcopy(self._instances) + for inst in candidates.values(): + before = _julabo_copy.deepcopy(inst['state']) + self._step_thermal(inst, float(dt_s)) + if any(isinstance(v, float) and not _julabo_math.isfinite(v) for v in inst['state'].values()): raise ValueError('Configuration produced nonfinite numerical state; step unchanged') + if inst['state'] != before: inst['revision'] += 1 + self._instances, self.time_s = candidates, self.time_s + float(dt_s) + faults = [] + if self.scene_adapter: + for key, inst in self._instances.items(): + try: self.scene_adapter(key, _julabo_copy.deepcopy(inst['state'])) + except Exception: faults.append({'instance_id': key, 'time_s': self.time_s, 'code': 'SCENE_SYNCHRONIZATION_FAILED'}) + self._scene_faults.extend(faults) + if faults: raise SceneSynchronizationError('Process and clock advanced; scene synchronization failed with possible partial backend effects') from None + + def sync_scene(self, instance_ids=None): + with self._lock: + if self.scene_adapter is None: raise RuntimeError('Scene adapter required') + ids = list(self._instances) if instance_ids is None else list(instance_ids) + if any(not isinstance(key, str) or key not in self._instances for key in ids): raise ValueError('Unknown instance') + for key in ids: + try: self.scene_adapter(key, _julabo_copy.deepcopy(self._instances[key]['state'])) + except Exception: raise SceneSynchronizationError('Scene synchronization failed; backend effects unknown') from None + + +class JulaboCorioCD200FSession: + """Agent-facing adapter with immutable host-registered identity and scope.""" + def __init__(self, host, principal_id): + if principal_id not in host._principals: raise ValueError('Host identity required') + self.__host, self.__principal_id = host, principal_id + + def _instance(self, instance_id): + if not isinstance(instance_id, str): return None + scope = self.__host._principals[self.__principal_id][1] + return self.__host._instances.get(instance_id) if scope is None or instance_id in scope else None + + def _visible(self, slot): return slot['visibility'] == 'agent' or self.__host._principals[self.__principal_id][0] in ('debug', 'evaluator') + + def _envelope(self, instance_id, request_id=None, *, result=None, observations=None, status='succeeded', error=None): + inst = self._instance(instance_id) + return {'protocol_version': PROTOCOL_VERSION, 'instance_id': instance_id, 'request_id': request_id, 'operation_id': None, 'status': status, + 'state_revision': inst['revision'] if inst else None, 'clock': {'domain': 'simulation', 'time_s': self.__host.time_s}, + 'result': {} if result is None else result, 'observations': {} if observations is None else observations, 'error': error} + + def _error(self, instance_id, code, request_id=None, status='rejected'): + messages = {'UNKNOWN_INSTANCE': 'Instance is unavailable.', 'UNKNOWN_CAPABILITY': 'Capability is unavailable.', 'INVALID_ARGUMENT': 'Arguments do not match the declared input.', 'PRECONDITION_FAILED': 'Declared operation preconditions are not met.', 'ACCESS_DENIED': 'Requested operation is outside session access.', 'REQUEST_CONFLICT': 'Request ID was already used with different arguments.', 'UNSUPPORTED': 'Required implementation backend is unavailable.', 'DEVICE_ERROR': 'Scene callback failed; runtime unchanged; backend effects unknown.'} + return self._envelope(instance_id, request_id, status=status, error={'code': code, 'message': messages.get(code, 'Operation failed.'), 'retryable': False, 'side_effects': 'unknown' if code == 'DEVICE_ERROR' else 'none'}) + + def describe(self, *, instance_id=None, asset_type_id=None): + with self.__host._lock: + if (instance_id is None) == (asset_type_id is None): return self._error(instance_id, 'INVALID_ARGUMENT') + if instance_id is not None and not self._instance(instance_id): return self._error(instance_id, 'UNKNOWN_INSTANCE') + if asset_type_id is not None and asset_type_id != JULABO_CORIO_CD200F_TYPE: return self._error(instance_id, 'UNKNOWN_INSTANCE') + spec = self.__host._metadata['asset_types'][JULABO_CORIO_CD200F_TYPE] + caps = _julabo_copy.deepcopy(spec['capabilities']) + for cap in caps.values(): + cap['state_effects'] = [effect for effect in cap['state_effects'] if self._visible(spec['state_slots'][effect['state_id']])] + if self.__host.scene_adapter is None: caps['scene.set_bath_lid']['availability'] = 'unsupported' + return {'protocol_version': PROTOCOL_VERSION, 'instance_id': instance_id, 'asset_type_id': JULABO_CORIO_CD200F_TYPE, 'asset_version': spec['asset_version'], + 'adapter': 'JulaboCorioCD200FSession', 'capabilities': caps, + 'state_slots': _julabo_copy.deepcopy({sid: slot for sid, slot in spec['state_slots'].items() if self._visible(slot)}), + 'limitations': _julabo_copy.deepcopy(self.__host._metadata['limitations'])} + + def read(self, *, instance_id, state_ids=None): + with self.__host._lock: + inst = self._instance(instance_id) + if not inst: return self._error(instance_id, 'UNKNOWN_INSTANCE') + slots = self.__host._metadata['asset_types'][JULABO_CORIO_CD200F_TYPE]['state_slots'] + if state_ids is None: state_ids = [sid for sid, slot in slots.items() if self._visible(slot)] + if not isinstance(state_ids, list) or any(not isinstance(sid, str) for sid in state_ids) or len(set(state_ids)) != len(state_ids): return self._error(instance_id, 'INVALID_ARGUMENT') + if any(sid not in slots or not self._visible(slots[sid]) for sid in state_ids): return self._error(instance_id, 'ACCESS_DENIED') + observations = {} + for sid in state_ids: + slot, value = slots[sid], _julabo_copy.deepcopy(inst['state'][sid]) + observations[sid] = {'value': value, 'unit': slot['unit'], 'quality': 'unavailable' if value is None else 'estimated' if slot['origin'] == 'derived' else 'valid', 'sample_time_s': self.__host.time_s, + 'sample_window_s': [inst['energy_start_s'], self.__host.time_s] if slot['sampling']['mode'] == 'integral' else None} + if value is None: observations[sid]['reason'] = 'Required host bath model or external circulation boundary is not configured.' + return self._envelope(instance_id, observations=observations) + + def invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if not inst: return self._error(instance_id, 'UNKNOWN_INSTANCE', request_id) + if not isinstance(capability_id, str) or not isinstance(request_id, str) or not request_id or len(request_id) > 256 or not isinstance(arguments, dict): return self._error(instance_id, 'INVALID_ARGUMENT', request_id) + try: digest = _julabo_hashlib.sha256(_julabo_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False, separators=(',', ':')).encode()).hexdigest() + except (ValueError, TypeError, OverflowError): return self._error(instance_id, 'INVALID_ARGUMENT', request_id) + key = (self.__principal_id, instance_id, request_id) + if key in host._requests: + previous, response = host._requests[key] + return _julabo_copy.deepcopy(response) if digest == previous else self._error(instance_id, 'REQUEST_CONFLICT', request_id) + response = self._invoke_checked(instance_id, inst, capability_id, arguments, request_id) + host._requests[key] = (digest, _julabo_copy.deepcopy(response)) + host._logs[self.__principal_id].append({'instance_id': instance_id, 'capability_id': capability_id, 'request_id': request_id, 'response': _julabo_copy.deepcopy(response)}) + return response + + def _invoke_checked(self, instance_id, inst, capability, args, request_id): + host, state = self.__host, inst['state'] + fail = lambda code, status='rejected': self._error(instance_id, code, request_id, status) + caps = host._metadata['asset_types'][JULABO_CORIO_CD200F_TYPE]['capabilities'] + if capability not in caps: return fail('UNKNOWN_CAPABILITY') + schema = caps[capability]['input_schema']['properties'] + if set(args) != set(schema): return fail('INVALID_ARGUMENT') + for name, item in schema.items(): + value = args[name] + if item['type'] == 'boolean' and type(value) is not bool: return fail('INVALID_ARGUMENT') + if item['type'] == 'number' and (not _julabo_number(value) or not item.get('minimum', -float('inf')) <= value <= item.get('maximum', float('inf'))): return fail('INVALID_ARGUMENT') + if capability.startswith('scene.') and host.scene_adapter is None: return fail('UNSUPPORTED', 'unsupported') + if capability == 'power.set': + updates, result = {'power.enabled': args['enabled']}, {'enabled': args['enabled']} + if not args['enabled']: updates.update({'circulation.running': False, 'circulation.flow_rate_m3_s': 0.0, 'circulation.pressure_rise_pa': 0.0}) + elif capability == 'thermal.set_temperature': + if not state['power.enabled']: return fail('PRECONDITION_FAILED') + cfg = inst['thermal_configuration'] + if cfg and not cfg['minimum_temperature_K'] <= args['temperature_K'] <= cfg['maximum_temperature_K']: return fail('PRECONDITION_FAILED') + updates, result = {'thermal.target_k': float(args['temperature_K'])}, {'setpoint_K': float(args['temperature_K'])} + elif capability == 'circulation.set_running': + if args['running'] and not (state['power.enabled'] and state['thermal.model_configured']): return fail('PRECONDITION_FAILED') + running, boundary = args['running'], inst['circulation_boundary'] + updates = {'circulation.running': running, 'circulation.flow_rate_m3_s': (boundary['flow_rate_m3_s'] if boundary else None) if running else 0.0, + 'circulation.pressure_rise_pa': (boundary['pressure_rise_Pa'] if boundary else None) if running else 0.0} + result = {'running': running} + else: updates, result = {'bath_lid.angle_rad': float(args['angle_rad'])}, {'angle_rad': float(args['angle_rad'])} + changed = {sid: value for sid, value in updates.items() if value != state[sid]} + if changed: + try: host._push_before_commit(instance_id, changed) + except RuntimeError: return fail('DEVICE_ERROR', 'failed') + state.update(changed) + inst['revision'] += 1 + return self._envelope(instance_id, request_id, result=result) + + def write(self, *, instance_id, state_id, value, request_id): + with self.__host._lock: + if not self._instance(instance_id): return self._error(instance_id, 'UNKNOWN_INSTANCE', request_id) + slots = self.__host._metadata['asset_types'][JULABO_CORIO_CD200F_TYPE]['state_slots'] + slot = slots.get(state_id) if isinstance(state_id, str) else None + if slot is None or not self._visible(slot) or slot['access'] != 'read_write': return self._error(instance_id, 'ACCESS_DENIED', request_id) + route = slot['write_via'] + return self.invoke(instance_id=instance_id, capability_id=route['capability_id'], arguments={route['parameter']: value}, request_id=request_id) + + def logs(self): + with self.__host._lock: return _julabo_copy.deepcopy(self.__host._logs[self.__principal_id]) +# END CHEM-187 JULABO CORIO CD-200F runtime. + +# BEGIN CHEM-191 Miele PLW 6111 DP SC CL H14 runtime (append-only asset scope). +import copy as _miele_copy +import hashlib as _miele_hashlib +import json as _miele_json +import math as _miele_math +import threading as _miele_threading + +MIELE_PLW6111_TYPE = 'instrument.miele_plw6111' +MIELE_PLW6111_SOURCE = 'https://media.miele.com/downloads/n-/gb/FS_10958380_GBE_GB-en-GB.pdf' +MIELE_PLW6111_WATER_POWER_W = 7500.0 +MIELE_PLW6111_BASKETS = ('lower', 'middle', 'upper') + + +def _miele_number(value): + return type(value) in (int, float) and _number(value) + + +def _miele_object(properties): + return {'type': 'object', 'properties': properties, 'required': list(properties), 'additionalProperties': False} + + +def _miele_schema(unit, minimum=None, maximum=None, nullable=False): + result = {'type': 'number', 'x-unit': unit} + if minimum is not None: result['minimum'] = minimum + if maximum is not None: result['maximum'] = maximum + return {'anyOf': [result, {'type': 'null'}]} if nullable else result + + +def export_miele_plw6111_metadata(): + """Static metadata only; all unknown manufacturer thermal parameters are null.""" + def route(capability, parameter, **fixed): + return {'capability_id': capability, 'parameter': parameter, 'fixed_arguments': fixed} + def slot(unit, origin, component, meaning, schema, route_value=None, integral=False): + return {'unit': unit, 'origin': origin, 'component_id': component, 'meaning_zh': meaning, + 'visibility': 'debug' if origin == 'process_truth' else 'agent', + 'access': 'read_write' if route_value else 'read_only', 'write_via': route_value, + 'value_schema': schema, 'reference_conditions': None, + 'sampling': {'mode': 'integral' if integral else 'instant', 'time_domain': 'simulation', 'window': 'Since explicit host water model configuration' if integral else None}} + slots = { + 'power.enabled': slot('1', 'setpoint', 'display', '本机供电许可', {'type': 'boolean'}, route('power.set', 'enabled')), + 'thermal.target_k': slot('K', 'setpoint', 'display', '水温目标；不代表实际水温或热风温度', _miele_schema('K', 273.15, 373.15), route('thermal.set_temperature', 'temperature_K')), + 'water.temperature_k': slot('K', 'process_truth', 'water_heater', '单节点有效洗涤水温真值；未配置模型为null', _miele_schema('K', nullable=True)), + 'water.indicated_temperature_k': slot('K', 'derived', 'display', '0.1°C网格取整的理想化水温显示，未模拟传感器噪声或精度', _miele_schema('K', nullable=True)), + 'water.model_configured': slot('1', 'derived', 'water_heater', '宿主显式配置了水热模型', {'type': 'boolean'}), + 'door.angle_rad': slot('rad', 'scene', 'door', '门关节角度，0关闭，pi/2示意全开；机械映射见模型绑定', _miele_schema('rad', 0, _miele_math.pi / 2)), + 'door.closed': slot('1', 'derived', 'door', '模拟门闭合条件，不是实机互锁传感器', {'type': 'boolean'}), + 'program.running': slot('1', 'derived', 'display', '当前模拟程序运行中', {'type': 'boolean'}), + 'program.phase': slot('1', 'derived', 'display', '清洗、漂洗、干燥计时状态机；不是清洁度或含水率判据', {'type': 'string', 'enum': ['idle', 'wash', 'rinse', 'dry', 'completed', 'stopped']}), + 'program.phase_elapsed_s': slot('s', 'derived', 'display', '本阶段已完成计时；洗涤/漂洗须达到目标水温才计时', _miele_schema('s', 0)), + 'program.configured': slot('1', 'derived', 'display', '已显式设置三个模拟阶段时长', {'type': 'boolean'}), + } + for name in MIELE_PLW6111_BASKETS: + sid = 'basket.' + name + '.extension_m' + slots[sid] = slot('m', 'scene', 'basket_' + name, '三层篮架槽位前拉距离，0归位；0.4m为仿真行程假设', _miele_schema('m', 0, .4), route('basket.set_position', 'extension_m', slot=name)) + for name in ('wash', 'rinse', 'dry'): + slots['program.' + name + '_s'] = slot('s', 'setpoint', 'display', '宿主任务指定的模拟阶段时长，非厂家程序配方', _miele_schema('s', 0, 86400, nullable=True)) + for name, meaning in (('heater_energy_j', '累计水加热输入'), ('environment_energy_j', '累计水向环境放热'), ('stored_energy_change_j', '相对显式初始化的水热储能变化')): + slots['water.' + name] = slot('J', 'process_truth', 'water_heater', meaning, _miele_schema('J'), integral=True) + for sid, item in slots.items(): + item['read_binding'] = "MielePLW6111Session.read(instance_id=..., state_ids=['" + sid + "'])" + if item['origin'] == 'derived': item['observation_note_zh'] = '仿真派生观测标记estimated；缺测标记unavailable；不是厂家实测数据。' + defs = { + 'power.set': ({'enabled': {'type': 'boolean'}}, {'enabled': {'type': 'boolean'}}, {'enabled': True}, ['display'], ['power.enabled'], ['power.enabled', 'program.running', 'program.phase'], '设置供电；断电停止程序，保留已经发生的温度及计时。'), + 'thermal.set_temperature': ({'temperature_K': _miele_schema('K', 273.15, 373.15)}, {'setpoint_K': _miele_schema('K')}, {'temperature_K': 333.15}, ['display', 'water_heater'], ['thermal.target_k'], ['thermal.target_k'], '只写目标水温；运行中不允许改温。实际加热只随宿主step在清洗/漂洗阶段进行。'), + 'door.open': ({}, {'angle_rad': _miele_schema('rad'), 'closed': {'type': 'boolean'}}, {}, ['door'], ['door.angle_rad', 'door.closed'], ['door.angle_rad', 'door.closed'], '程序停止时打开门关节；需要真实场景回调，不代表机器人抓取。'), + 'door.close': ({}, {'angle_rad': _miele_schema('rad'), 'closed': {'type': 'boolean'}}, {}, ['door'], ['door.angle_rad', 'door.closed'], ['door.angle_rad', 'door.closed'], '三篮架均归位且程序停止时关闭门关节。'), + 'basket.set_position': ({'slot': {'type': 'string', 'enum': list(MIELE_PLW6111_BASKETS)}, 'extension_m': _miele_schema('m', 0, .4)}, {'slot': {'type': 'string', 'enum': list(MIELE_PLW6111_BASKETS)}, 'extension_m': _miele_schema('m', 0, .4)}, {'slot': 'lower', 'extension_m': .2}, ['basket_' + s for s in MIELE_PLW6111_BASKETS], ['basket.' + s + '.extension_m' for s in MIELE_PLW6111_BASKETS], ['basket.' + s + '.extension_m' for s in MIELE_PLW6111_BASKETS], '门全开且程序停止时设置单个篮架沿-Y的前拉位置；不是玻璃器皿放置或物流转移。'), + 'washing.configure_program': ({name + '_s': _miele_schema('s', 1 if name != 'dry' else 0, 86400) for name in ('wash', 'rinse', 'dry')}, {'configured': {'type': 'boolean'}}, {'wash_s': 60, 'rinse_s': 30, 'dry_s': 30}, ['display'], ['program.configured'], ['program.configured', 'program.wash_s', 'program.rinse_s', 'program.dry_s', 'program.phase', 'program.phase_elapsed_s'], '显式配置三个阶段时长；不是厂家内置程序、化学配方或清洁度模型。'), + 'washing.start': ({}, {'running': {'type': 'boolean'}}, {}, ['display', 'water_heater'], ['program.running'], ['program.running', 'program.phase', 'program.phase_elapsed_s'], '从wash阶段开始；必须供电、门关、三篮架归位、水热模型与程��均已配置。'), + 'washing.stop': ({}, {'running': {'type': 'boolean'}}, {}, ['display', 'water_heater'], ['program.running'], ['program.running', 'program.phase'], '停止后续程序与加热，保留已发生的水温、阶段计时及累计能量。'), + } + caps = {} + for name, (args, outputs, example, components, observes, immediate, meaning) in defs.items(): + pre = [] + if name in ('thermal.set_temperature', 'washing.configure_program', 'washing.start'): + pre.append({'description_zh': '已上电且没有运行中的程序', 'state_ids': ['power.enabled', 'program.running'], 'enforced_by': 'adapter', 'check': 'power.enabled and not program.running'}) + if name == 'thermal.set_temperature': + pre.append({'description_zh': '目标不低于宿主环境，若水模型已配置则不得超过其明确液态适用上限；273.15..373.15K仅模拟输入域', 'state_ids': ['water.model_configured'], 'enforced_by': 'adapter', 'check': 'ambient_K <= temperature_K <= configured maximum if configured'}) + if name in ('door.open', 'door.close', 'basket.set_position'): + pre.append({'description_zh': '程序停止且已注册同步场景适配器', 'state_ids': ['program.running'], 'enforced_by': 'adapter', 'check': 'not program.running and scene_adapter is not None'}) + if name == 'door.close': + pre.append({'description_zh': '三层篮架均归位', 'state_ids': ['basket.' + s + '.extension_m' for s in MIELE_PLW6111_BASKETS], 'enforced_by': 'adapter', 'check': 'all extensions == 0'}) + if name == 'basket.set_position': + pre.append({'description_zh': '门已全开', 'state_ids': ['door.angle_rad'], 'enforced_by': 'adapter', 'check': 'door.angle_rad == pi/2'}) + if name == 'washing.start': + pre.append({'description_zh': '门关、三架归位、模型和程序配置已完成', 'state_ids': ['door.closed', 'water.model_configured', 'program.configured'] + ['basket.' + s + '.extension_m' for s in MIELE_PLW6111_BASKETS], 'enforced_by': 'adapter', 'check': 'door.closed and all extensions == 0 and water.model_configured and program.configured'}) + effects = [{'state_id': sid, 'timing': 'immediate', 'description_zh': meaning} for sid in immediate] + if name in ('power.set', 'washing.start', 'washing.stop'): + effects += [{'state_id': sid, 'timing': 'on_step', 'description_zh': '宿主推进有限功率水热响应及三阶段状态机；干燥仅计时，不计算热风或含水率'} for sid in ('water.temperature_k', 'water.indicated_temperature_k', 'water.heater_energy_j', 'water.environment_energy_j', 'water.stored_energy_change_j', 'program.running', 'program.phase', 'program.phase_elapsed_s')] + caps[name] = {'availability': 'implemented', 'visibility': 'agent', 'kind': 'configuration' if name == 'washing.configure_program' else 'simulation' if name in ('door.open', 'door.close', 'basket.set_position') else 'device_command', + 'component_ids': components, 'description_zh': meaning, 'input_schema': _miele_object(args), 'output_schema': _miele_object(outputs), 'example_arguments': [example], + 'observes': observes, 'state_effects': effects, 'preconditions': pre, 'scene_backend_required': name in ('door.open', 'door.close', 'basket.set_position'), + 'binding': "basic40_runtime_thermal.MielePLW6111Session.invoke(instance_id=..., capability_id='" + name + "', arguments=..., request_id=...)", + 'completion_criterion_zh': '同步成功仅确认本次设定/程序许可/关节设置；洗涤状态随后由宿主step推进。program.phase=completed只证明三个模拟计时完成。'} + def p(value, unit, evidence, source): return {'value': value, 'unit': unit, 'evidence': evidence, 'source': source} + params = { + 'water_heater_power_W': p(7500.0, 'W', 'public_document', MIELE_PLW6111_SOURCE + '; water heating rated power; never applied to drying air'), + 'thermal_capacity_J_K': p(None, 'J/K', 'unknown', 'No manufacturer water charge/effective heat capacity identified; explicit host configuration required; no oven parameter reuse.'), + 'heat_loss_W_K': p(None, 'W/K', 'unknown', 'One rated power cannot identify C and UA; explicit host assumption required.'), + 'water_charge_kg': p(None, 'kg', 'unknown', 'No inferred charge from chamber volume or 251kg whole-machine mass.'), + 'manufacturer_heatup_s': p(None, 's', 'unknown', 'No independently documented heat-up time in the present evidence.'), + 'manufacturer_maximum_water_temperature_K': p(None, 'K', 'unknown', 'Not inferred from generic washer family specifications.'), + 'drying_air_temperature_K': p(None, 'K', 'unknown', 'Dry state is a timer only; no drying-air energy or moisture model.'), + 'basket_extension_limit_m': p(.4, 'm', 'assumption', 'Illustrative three-slot front extension, not measured manufacturer travel.'), + 'door_angle_limit_rad': p(_miele_math.pi / 2, 'rad', 'assumption', 'Illustrative full-open mechanical angle; actual scene mapping defined in model bindings.'), + 'whole_machine_mass_kg': p(251.0, 'kg', 'public_document', MIELE_PLW6111_SOURCE + '; not used for component inertia or water heat capacity'), + } + limitations = ['Water-only single-node heat equation C*dT/dt=P-UA*(T-Ta); rated P<=7500W only in wash/rinse. Explicit host C and UA are assumptions, not manufacturer calibration.', + 'All actual water charge, component thermal capacities, heat losses and heat-up time remain unknown (null). Example test parameters do not become product defaults.', + 'Three serial phases share one effective water node; filling, draining, rinse water exchange, detergent dosing, spray hydraulics, thermal disinfection, soil removal and material transfer are not modeled.', + 'Dry phase is timed only; 7500W is never applied to drying air. No moisture, drying effectiveness, H14 filtration or drying-air thermal solver.', + 'Program times are explicit simulation settings, not factory recipes. Wash/rinse timers start at target water temperature; unreachable targets leave the phase running until stopped.', + 'Scene controls require a synchronous adapter; no robot grasp, contact simulation or physical hardware connection.', + 'API truth filtering is implemented for session metadata, observations, responses and logs; it is not a Python introspection or filesystem security sandbox. Do not give agents the trusted host or debug output files.', + 'Request deduplication is in-memory only. No operation/poll/cancel objects; start/stop are synchronous commands controlling subsequent host evolution.'] + host = {'sim.step': {'kind': 'simulation', 'visibility': 'trusted_host_only', 'input_schema': _miele_object({'dt_s': _miele_schema('s', 0, 86400)}), 'binding': 'MielePLW6111Runtime.step(dt_s)', 'partial_failure': 'Process and world clock commit before scene callbacks. SceneSynchronizationError reports possible partial backend effects.'}, + 'sim.configure_water_model': {'kind': 'configuration', 'visibility': 'trusted_host_only', 'binding': 'MielePLW6111Runtime.configure_water_model(instance_id, *, effective_heat_capacity_J_K, heat_loss_W_K, initial_temperature_K, maximum_temperature_K, evidence)', 'description_zh': '断电且程序停止时显式初始化有效水热模型；所有参数均为有说明的宿主输入，不是注水或真实硬件重置。'}} + return {'asset_types': {MIELE_PLW6111_TYPE: {'catalog_id': 'CHEM-191', 'model': 'Miele PLW 6111 DP SC CL H14, 10958380', 'asset_version': '1.0.0', 'state_slots': slots, 'capabilities': caps, 'declared_capabilities': {}, 'parameters': params}}, 'host_capabilities': host, + 'limitations': limitations, 'trusted_scene_callback': 'scene_adapter(instance_id, updates) receives SI door, three basket extensions, indicated water temperature and program phase; host is sole authority.', 'result_schema_scope': 'capability.output_schema validates response.result only'} + + +class MielePLW6111Runtime: + """Trusted independent multi-instance host. Supply sessions to agents.""" + def __init__(self, *, ambient_temperature_K=293.15, scene_adapter=None): + if not _miele_number(ambient_temperature_K) or not 273.15 <= ambient_temperature_K <= 313.15: raise ValueError('Finite ambient in assumed 273.15..313.15K envelope required') + self.ambient_temperature_K, self.scene_adapter, self.time_s = float(ambient_temperature_K), scene_adapter, 0.0 + self._instances, self._requests, self._scene_faults = {}, {}, [] + self._principals, self._logs = {'__miele_public__': ('agent', None)}, {'__miele_public__': []} + self._lock, self._metadata = _miele_threading.RLock(), export_miele_plw6111_metadata() + self._agent = MielePLW6111Session(self, '__miele_public__') + + def _scene_values(self, state): + return {sid: _miele_copy.deepcopy(value) for sid, value in state.items() if sid.startswith('basket.') or sid in ('power.enabled', 'door.angle_rad', 'door.closed', 'water.indicated_temperature_k', 'program.phase', 'program.running')} + + def _push_before_commit(self, instance_id, state): + if self.scene_adapter: + try: self.scene_adapter(instance_id, self._scene_values(state)) + except Exception: raise RuntimeError('Scene callback failed; runtime unchanged; backend effects unknown') from None + + def create_instance(self, instance_id, asset_type_id=MIELE_PLW6111_TYPE): + with self._lock: + if not isinstance(instance_id, str) or not instance_id or instance_id in self._instances or asset_type_id != MIELE_PLW6111_TYPE: raise ValueError('Unique nonempty instance ID and declared Miele asset type required') + state = {'power.enabled': False, 'thermal.target_k': self.ambient_temperature_K, 'water.temperature_k': None, 'water.indicated_temperature_k': None, 'water.model_configured': False, + 'door.angle_rad': 0.0, 'door.closed': True, 'program.running': False, 'program.phase': 'idle', 'program.phase_elapsed_s': 0.0, 'program.configured': False, + 'program.wash_s': None, 'program.rinse_s': None, 'program.dry_s': None, 'water.heater_energy_j': 0.0, 'water.environment_energy_j': 0.0, 'water.stored_energy_change_j': 0.0} + state.update({'basket.' + name + '.extension_m': 0.0 for name in MIELE_PLW6111_BASKETS}) + self._push_before_commit(instance_id, state) + self._instances[instance_id] = {'state': state, 'revision': 0, 'water_configuration': None, 'energy_start_s': self.time_s} + + def register_principal(self, principal_id, *, visibility, instance_ids=None): + with self._lock: + if not isinstance(principal_id, str) or not principal_id or principal_id in self._principals or visibility not in ('agent', 'debug', 'evaluator'): raise ValueError('Unique host identity and valid visibility required') + if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(x, str) for x in instance_ids)): raise ValueError('Scope must be a collection of instance IDs') + scope = None if instance_ids is None else frozenset(instance_ids) + if scope is not None and not scope <= self._instances.keys(): raise ValueError('Unknown instance in scope') + self._principals[principal_id], self._logs[principal_id] = (visibility, scope), [] + + def session(self, principal_id): + if not isinstance(principal_id, str) or principal_id not in self._principals: raise ValueError('Host identity required') + return MielePLW6111Session(self, principal_id) + + def describe(self, **kwargs): return self._agent.describe(**kwargs) + def read(self, **kwargs): return self._agent.read(**kwargs) + def invoke(self, **kwargs): return self._agent.invoke(**kwargs) + def write(self, **kwargs): return self._agent.write(**kwargs) + def describe_host(self): return _miele_copy.deepcopy(self._metadata['host_capabilities']) + + def debug_snapshot(self): + with self._lock: return _miele_copy.deepcopy({'time_s': self.time_s, 'instances': self._instances, 'scene_faults': self._scene_faults}) + + def configure_water_model(self, instance_id, *, effective_heat_capacity_J_K, heat_loss_W_K, initial_temperature_K, maximum_temperature_K, evidence): + with self._lock: + values = (effective_heat_capacity_J_K, heat_loss_W_K, initial_temperature_K, maximum_temperature_K) + if not isinstance(instance_id, str) or instance_id not in self._instances or not all(_miele_number(x) for x in values) or not isinstance(evidence, str) or not evidence.strip(): raise ValueError('Known instance, finite explicit model parameters and evidence required') + if effective_heat_capacity_J_K <= 0 or heat_loss_W_K < 0 or not self.ambient_temperature_K <= initial_temperature_K <= maximum_temperature_K <= 373.15 or maximum_temperature_K <= self.ambient_temperature_K: raise ValueError('Positive C, nonnegative UA and explicit liquid-water temperature envelope required') + inst = self._instances[instance_id] + if inst['state']['power.enabled'] or inst['state']['program.running']: raise ValueError('Configure only when powered off and stopped') + cfg = dict(zip(('effective_heat_capacity_J_K', 'heat_loss_W_K', 'initial_temperature_K', 'maximum_temperature_K'), map(float, values))) + cfg['evidence'] = evidence + state = _miele_copy.deepcopy(inst['state']) + state.update({'water.temperature_k': float(initial_temperature_K), 'water.indicated_temperature_k': self._indicate(initial_temperature_K), 'thermal.target_k': float(initial_temperature_K), 'water.model_configured': True, + 'water.heater_energy_j': 0.0, 'water.environment_energy_j': 0.0, 'water.stored_energy_change_j': 0.0}) + self._push_before_commit(instance_id, state) + inst.update(state=state, water_configuration=cfg, revision=inst['revision'] + 1, energy_start_s=self.time_s) + + @staticmethod + def _indicate(temperature_K): return round(temperature_K - 273.15, 1) + 273.15 + + def _time_to_target(self, inst): + state, cfg = inst['state'], inst['water_configuration'] + t, goal, ta = state['water.temperature_k'], state['thermal.target_k'], self.ambient_temperature_K + if t >= goal: return 0.0 + c, ua, p = cfg['effective_heat_capacity_J_K'], cfg['heat_loss_W_K'], MIELE_PLW6111_WATER_POWER_W + if ua == 0: return c * (goal - t) / p + equilibrium = ta + p / ua + if goal >= equilibrium: return float('inf') + return c / ua * _miele_math.log((equilibrium - t) / (equilibrium - goal)) + + def _water_step(self, inst, dt_s, heating): + if not dt_s or inst['water_configuration'] is None: return + s, cfg = inst['state'], inst['water_configuration'] + c, ua, ta, goal = cfg['effective_heat_capacity_J_K'], cfg['heat_loss_W_K'], self.ambient_temperature_K, s['thermal.target_k'] + remaining, energy = dt_s, 0.0 + t = s['water.temperature_k'] + # Exact constant-power/loss intervals with event splitting at the setpoint. + while remaining > 1e-12: + if heating and t < goal: + p = MIELE_PLW6111_WATER_POWER_W + tau = self._time_to_target({**inst, 'state': {**s, 'water.temperature_k': t}}) + elif heating and t == goal: + p, tau = min(MIELE_PLW6111_WATER_POWER_W, ua * (goal - ta)), float('inf') + else: + p, tau = 0.0, float('inf') + if heating and t > goal and goal > ta and ua > 0: tau = c / ua * _miele_math.log((t - ta) / (goal - ta)) + duration = min(remaining, tau) + new_t = t + p * duration / c if ua == 0 else ta + (t - ta) * _miele_math.exp(-ua * duration / c) + p / ua * (-_miele_math.expm1(-ua * duration / c)) + if tau <= remaining: new_t = goal + energy += p * duration + remaining -= duration + t = new_t + if duration == 0: break + change = c * (t - s['water.temperature_k']) + s['water.temperature_k'], s['water.indicated_temperature_k'] = t, self._indicate(t) + s['water.heater_energy_j'] += energy + s['water.environment_energy_j'] += energy - change + s['water.stored_energy_change_j'] = c * (t - cfg['initial_temperature_K']) + + def _advance(self, inst, dt_s): + s, remaining = inst['state'], dt_s + while remaining > 1e-10: + if not s['program.running']: + self._water_step(inst, remaining, False) + break + phase = s['program.phase'] + heating = phase in ('wash', 'rinse') and s['power.enabled'] + if heating: + wait = self._time_to_target(inst) + if wait > 0: + advance = min(remaining, wait) + self._water_step(inst, advance, True) + remaining -= advance + if wait > advance: break + # Exact event snap prevents floating-point drift blocking a timer. + s['water.temperature_k'] = s['thermal.target_k'] + s['water.indicated_temperature_k'] = self._indicate(s['thermal.target_k']) + left = s['program.' + phase + '_s'] - s['program.phase_elapsed_s'] + advance = min(remaining, max(0.0, left)) + self._water_step(inst, advance, heating) + s['program.phase_elapsed_s'] += advance + remaining -= advance + if left - advance <= 1e-9: + if phase == 'dry': s.update({'program.running': False, 'program.phase': 'completed', 'program.phase_elapsed_s': s['program.dry_s']}) + elif phase == 'rinse' and s['program.dry_s'] == 0: s.update({'program.running': False, 'program.phase': 'completed', 'program.phase_elapsed_s': 0.0}) + else: s.update({'program.phase': 'rinse' if phase == 'wash' else 'dry', 'program.phase_elapsed_s': 0.0}) + else: break + + def step(self, dt_s): + if not _miele_number(dt_s) or not 0 <= dt_s <= 86400: raise ValueError('dt_s must be finite in [0,86400]') + if not dt_s: return + with self._lock: + candidates = _miele_copy.deepcopy(self._instances) + for inst in candidates.values(): + before = _miele_copy.deepcopy(inst['state']) + self._advance(inst, float(dt_s)) + if any(isinstance(value, float) and not _miele_math.isfinite(value) for value in inst['state'].values()): raise ValueError('Nonfinite model result; world step unchanged') + if before != inst['state']: inst['revision'] += 1 + self._instances, self.time_s = candidates, self.time_s + float(dt_s) + faults = [] + if self.scene_adapter: + for key, inst in self._instances.items(): + try: self.scene_adapter(key, self._scene_values(inst['state'])) + except Exception: faults.append({'instance_id': key, 'time_s': self.time_s, 'code': 'SCENE_SYNCHRONIZATION_FAILED'}) + self._scene_faults.extend(faults) + if faults: raise SceneSynchronizationError('World process and time advanced; scene synchronization failed; backend effects may be partial') from None + + def sync_scene(self, instance_ids=None): + with self._lock: + if self.scene_adapter is None: raise RuntimeError('Scene adapter required') + ids = list(self._instances) if instance_ids is None else list(instance_ids) + if any(not isinstance(key, str) or key not in self._instances for key in ids): raise ValueError('Unknown instance') + for key in ids: + try: self.scene_adapter(key, self._scene_values(self._instances[key]['state'])) + except Exception: raise SceneSynchronizationError('Scene synchronization failed; backend effects unknown') from None + + +class MielePLW6111Session: + """Public adapter with host-authenticated, immutable identity and scope.""" + def __init__(self, host, principal_id): + if principal_id not in host._principals: raise ValueError('Host identity required') + self.__host, self.__principal = host, principal_id + + def _instance(self, instance_id): + if not isinstance(instance_id, str): return None + scope = self.__host._principals[self.__principal][1] + return self.__host._instances.get(instance_id) if scope is None or instance_id in scope else None + + def _visible(self, slot): return slot['visibility'] == 'agent' or self.__host._principals[self.__principal][0] in ('debug', 'evaluator') + + def _envelope(self, instance_id, request_id=None, *, result=None, observations=None, status='succeeded', error=None): + inst = self._instance(instance_id) + return {'protocol_version': PROTOCOL_VERSION, 'instance_id': instance_id if isinstance(instance_id, str) else None, 'request_id': request_id if isinstance(request_id, str) else None, + 'operation_id': None, 'status': status, 'state_revision': inst['revision'] if inst else None, 'clock': {'domain': 'simulation', 'time_s': self.__host.time_s}, + 'result': {} if result is None else _miele_copy.deepcopy(result), 'observations': {} if observations is None else observations, 'error': error} + + def _error(self, instance_id, code, request_id=None, status='rejected'): + messages = {'UNKNOWN_INSTANCE': 'Instance is unavailable in this session.', 'UNKNOWN_CAPABILITY': 'Capability is unavailable.', 'INVALID_ARGUMENT': 'Arguments do not match declared input.', 'ACCESS_DENIED': 'Requested state is outside session access.', 'PRECONDITION_FAILED': 'Required operation state or configuration is unavailable.', 'BUSY': 'Stop the active program before this command.', 'REQUEST_CONFLICT': 'Request ID already belongs to different arguments.', 'UNSUPPORTED': 'Required execution backend is unavailable.', 'DEVICE_ERROR': 'Scene callback failed; runtime unchanged; backend effects unknown.'} + return self._envelope(instance_id, request_id, status=status, error={'code': code, 'message': messages[code], 'retryable': False, 'side_effects': 'unknown' if code == 'DEVICE_ERROR' else 'none', 'progress': None}) + + def describe(self, *, instance_id=None, asset_type_id=None): + with self.__host._lock: + if (instance_id is None) == (asset_type_id is None): return self._error(instance_id, 'INVALID_ARGUMENT') + if instance_id is not None and not self._instance(instance_id): return self._error(instance_id, 'UNKNOWN_INSTANCE') + if asset_type_id is not None and asset_type_id != MIELE_PLW6111_TYPE: return self._error(instance_id, 'UNKNOWN_INSTANCE') + scope = self.__host._principals[self.__principal][1] + if scope is not None and not scope: return self._error(instance_id, 'ACCESS_DENIED') + spec = self.__host._metadata['asset_types'][MIELE_PLW6111_TYPE] + caps = _miele_copy.deepcopy(spec['capabilities']) + for cap in caps.values(): + cap['state_effects'] = [effect for effect in cap['state_effects'] if self._visible(spec['state_slots'][effect['state_id']])] + cap['observes'] = [sid for sid in cap['observes'] if self._visible(spec['state_slots'][sid])] + if cap['scene_backend_required'] and self.__host.scene_adapter is None: cap['availability'] = 'unsupported' + return {'protocol_version': PROTOCOL_VERSION, 'instance_id': instance_id, 'asset_type_id': MIELE_PLW6111_TYPE, 'asset_version': spec['asset_version'], 'adapter': 'MielePLW6111Session', 'capabilities': caps, + 'state_slots': _miele_copy.deepcopy({sid: slot for sid, slot in spec['state_slots'].items() if self._visible(slot)}), 'limitations': _miele_copy.deepcopy(self.__host._metadata['limitations'])} + + def read(self, *, instance_id, state_ids=None): + with self.__host._lock: + inst = self._instance(instance_id) + if not inst: return self._error(instance_id, 'UNKNOWN_INSTANCE') + slots = self.__host._metadata['asset_types'][MIELE_PLW6111_TYPE]['state_slots'] + if state_ids is None: state_ids = [sid for sid, slot in slots.items() if self._visible(slot)] + if not isinstance(state_ids, list) or any(not isinstance(sid, str) for sid in state_ids) or len(set(state_ids)) != len(state_ids): return self._error(instance_id, 'INVALID_ARGUMENT') + if any(sid not in slots or not self._visible(slots[sid]) for sid in state_ids): return self._error(instance_id, 'ACCESS_DENIED') + observations = {} + for sid in state_ids: + slot, value = slots[sid], _miele_copy.deepcopy(inst['state'][sid]) + observations[sid] = {'value': value, 'unit': slot['unit'], 'quality': 'unavailable' if value is None else 'estimated' if slot['origin'] == 'derived' else 'valid', 'sample_time_s': self.__host.time_s, + 'sample_window_s': [inst['energy_start_s'], self.__host.time_s] if slot['sampling']['mode'] == 'integral' else None} + if value is None: observations[sid]['reason'] = 'Required explicit simulation configuration is unavailable.' + return self._envelope(instance_id, observations=observations) + + def invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if not inst: return self._error(instance_id, 'UNKNOWN_INSTANCE', request_id) + if not isinstance(capability_id, str) or not isinstance(arguments, dict) or not isinstance(request_id, str) or not request_id or len(request_id) > 256: return self._error(instance_id, 'INVALID_ARGUMENT', request_id) + try: digest = _miele_hashlib.sha256(_miele_json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False, separators=(',', ':')).encode()).hexdigest() + except (TypeError, ValueError, OverflowError): return self._error(instance_id, 'INVALID_ARGUMENT', request_id) + key = (self.__principal, instance_id, request_id) + if key in host._requests: + previous, response = host._requests[key] + return _miele_copy.deepcopy(response) if previous == digest else self._error(instance_id, 'REQUEST_CONFLICT', request_id) + response = self._checked(instance_id, inst, capability_id, arguments, request_id) + host._requests[key] = (digest, _miele_copy.deepcopy(response)) + host._logs[self.__principal].append({'instance_id': instance_id, 'capability_id': capability_id, 'request_id': request_id, 'response': _miele_copy.deepcopy(response)}) + return response + + def _checked(self, instance_id, inst, capability, args, request_id): + host, state = self.__host, inst['state'] + fail = lambda code, status='rejected': self._error(instance_id, code, request_id, status) + caps = host._metadata['asset_types'][MIELE_PLW6111_TYPE]['capabilities'] + if capability not in caps: return fail('UNKNOWN_CAPABILITY') + schema = caps[capability]['input_schema']['properties'] + if set(args) != set(schema): return fail('INVALID_ARGUMENT') + for name, item in schema.items(): + value = args[name] + if item['type'] == 'boolean' and type(value) is not bool: return fail('INVALID_ARGUMENT') + if item['type'] == 'number' and (not _miele_number(value) or not item.get('minimum', -float('inf')) <= value <= item.get('maximum', float('inf'))): return fail('INVALID_ARGUMENT') + if item['type'] == 'string' and (not isinstance(value, str) or value not in item['enum']): return fail('INVALID_ARGUMENT') + if caps[capability]['scene_backend_required'] and host.scene_adapter is None: return fail('UNSUPPORTED', 'unsupported') + if capability not in ('power.set', 'washing.stop') and state['program.running']: return fail('BUSY') + if capability in ('thermal.set_temperature', 'washing.configure_program', 'washing.start') and not state['power.enabled']: return fail('PRECONDITION_FAILED') + if capability == 'power.set': + updates, result = {'power.enabled': args['enabled']}, {'enabled': args['enabled']} + if not args['enabled'] and state['program.running']: updates.update({'program.running': False, 'program.phase': 'stopped'}) + elif capability == 'thermal.set_temperature': + cfg = inst['water_configuration'] + if args['temperature_K'] < host.ambient_temperature_K or (cfg and args['temperature_K'] > cfg['maximum_temperature_K']): return fail('PRECONDITION_FAILED') + updates, result = {'thermal.target_k': float(args['temperature_K'])}, {'setpoint_K': float(args['temperature_K'])} + elif capability in ('door.open', 'door.close'): + closed = capability == 'door.close' + if closed and any(state['basket.' + name + '.extension_m'] != 0 for name in MIELE_PLW6111_BASKETS): return fail('PRECONDITION_FAILED') + updates = {'door.angle_rad': 0.0 if closed else _miele_math.pi / 2, 'door.closed': closed} + result = {'angle_rad': updates['door.angle_rad'], 'closed': closed} + elif capability == 'basket.set_position': + if state['door.angle_rad'] != _miele_math.pi / 2: return fail('PRECONDITION_FAILED') + updates, result = {'basket.' + args['slot'] + '.extension_m': float(args['extension_m'])}, {'slot': args['slot'], 'extension_m': float(args['extension_m'])} + elif capability == 'washing.configure_program': + updates = {'program.configured': True, 'program.phase': 'idle', 'program.phase_elapsed_s': 0.0, **{'program.' + name: float(value) for name, value in args.items()}} + result = {'configured': True} + elif capability == 'washing.start': + if not state['door.closed'] or not state['water.model_configured'] or not state['program.configured'] or any(state['basket.' + name + '.extension_m'] != 0 for name in MIELE_PLW6111_BASKETS): return fail('PRECONDITION_FAILED') + updates, result = {'program.running': True, 'program.phase': 'wash', 'program.phase_elapsed_s': 0.0}, {'running': True} + else: + updates, result = {'program.running': False, 'program.phase': 'stopped'}, {'running': False} + changed = {sid: value for sid, value in updates.items() if value != state[sid]} + if changed: + candidate = {**state, **changed} + try: host._push_before_commit(instance_id, candidate) + except RuntimeError: return fail('DEVICE_ERROR', 'failed') + state.update(changed) + inst['revision'] += 1 + return self._envelope(instance_id, request_id, result=result) + + def write(self, *, instance_id, state_id, value, request_id): + with self.__host._lock: + if not self._instance(instance_id): return self._error(instance_id, 'UNKNOWN_INSTANCE', request_id) + slots = self.__host._metadata['asset_types'][MIELE_PLW6111_TYPE]['state_slots'] + slot = slots.get(state_id) if isinstance(state_id, str) else None + if slot is None or not self._visible(slot) or slot['access'] != 'read_write': return self._error(instance_id, 'ACCESS_DENIED', request_id) + route = slot['write_via'] + return self.invoke(instance_id=instance_id, capability_id=route['capability_id'], arguments={**route.get('fixed_arguments', {}), route['parameter']: value}, request_id=request_id) + + def logs(self): + with self.__host._lock: return _miele_copy.deepcopy(self.__host._logs[self.__principal]) +# END CHEM-191 Miele PLW 6111 runtime. + +# BEGIN CHEM-047 Anton Paar Multiwave 7101 runtime (append-only batch scope). +MULTIWAVE_7101_TYPE = 'instrument.multiwave_7101' +MULTIWAVE_7101_POWER_W = 1500.0 +MULTIWAVE_7101_MAX_K = 573.15 +MULTIWAVE_7101_AMBIENT_K = 298.15 +MULTIWAVE_7101_REFERENCE_K = 448.15 +MULTIWAVE_7101_REFERENCE_S = 330.0 +MULTIWAVE_7101_REFERENCE_POWER_W = 1000.0 # Assumed absorbed power, not a measured value. +MULTIWAVE_7101_LOSS_W_K = 1.0 # Assumed UA; one time point cannot identify both C and UA. +MULTIWAVE_7101_CAPACITY_J_K = -MULTIWAVE_7101_LOSS_W_K * MULTIWAVE_7101_REFERENCE_S / math.log1p( + -MULTIWAVE_7101_LOSS_W_K * (MULTIWAVE_7101_REFERENCE_K - MULTIWAVE_7101_AMBIENT_K) / MULTIWAVE_7101_REFERENCE_POWER_W) +MULTIWAVE_7101_OPEN_LOSS_W_K = 5.0 # Assumed extra passive loss, not factory active cooling. +MULTIWAVE_7101_SOURCE = 'https://www.anton-paar.com/?L=1&document=60434&eID=documentsDownload' + + +def _multiwave_object(properties): + return {'type': 'object', 'properties': properties, 'required': list(properties), 'additionalProperties': False} + + +def _multiwave_number_schema(unit, minimum=None, maximum=None): + spec = {'type': 'number', 'x-unit': unit} + if minimum is not None: spec['minimum'] = minimum + if maximum is not None: spec['maximum'] = maximum + return spec + + +def export_multiwave_7101_metadata(): + """Public type metadata. No instance state or private truth is exported.""" + def slot(unit, origin, schema, *, visibility='agent', route=None): + return {'unit': unit, 'origin': origin, 'visibility': visibility, + 'access': 'read_write' if route else 'read_only', 'write_via': route, + 'value_schema': schema, 'reference_conditions': None, + 'sampling': {'mode': 'instant', 'time_domain': 'simulation', 'window': None}} + def route(cap, parameter): return {'capability_id': cap, 'parameter': parameter} + boolean = {'type': 'boolean'} + occupancy = {'type': 'array', 'minItems': 24, 'maxItems': 24, 'items': boolean} + slots = { + 'power.enabled': slot('1', 'setpoint', boolean, route=route('power.set', 'enabled')), + 'thermal.target_k': slot('K', 'setpoint', _multiwave_number_schema('K', 273.15, MULTIWAVE_7101_MAX_K), route=route('thermal.set_temperature', 'temperature_K')), + 'thermal.temperature_k': slot('K', 'process_truth', _multiwave_number_schema('K'), visibility='debug'), + 'thermal.indicated_temperature_k': slot('K', 'derived', _multiwave_number_schema('K')), + 'microwave.enabled': slot('1', 'setpoint', boolean, route=route('microwave.set_enabled', 'enabled')), + 'microwave.power_limit_w': slot('W', 'setpoint', _multiwave_number_schema('W', 0, 1500), route=route('microwave.set_power', 'power_W')), + 'microwave.delivered_power_w': slot('W', 'derived', _multiwave_number_schema('W', 0, 1500)), + 'door.angle_rad': slot('rad', 'scene', _multiwave_number_schema('rad', 0, math.pi / 2)), + 'door.closed': slot('1', 'derived', boolean), + 'rack.occupied_slots': slot('1', 'scene', occupancy), + 'rack.slot_count': slot('1', 'derived', {'type': 'integer', 'const': 24, 'x-unit': '1'}), + 'rack.slot_capacity_m3': slot('m^3', 'derived', _multiwave_number_schema('m^3', 8e-6, 8e-6)), + 'rack.pressure_limit_pa': slot('Pa', 'derived', {'type': 'null'}), + } + for sid in ('thermal.absorbed_energy_j', 'thermal.environment_energy_j', 'thermal.stored_energy_change_j'): + slots[sid] = slot('J', 'process_truth', _multiwave_number_schema('J'), visibility='debug') + for sid, info in slots.items(): + info['read_binding'] = f"Multiwave7101Session.read(instance_id=..., state_ids=['{sid}'])" + if info['origin'] == 'derived': info['observation_note_zh'] = '模拟派生或目录常量；温度与功率显示标记estimated，不是实测传感器。' + n = _multiwave_number_schema + defs = { + 'power.set': ({'enabled': boolean}, {'enabled': boolean}, {'enabled': True}, ['housing', 'controller'], ['power.enabled', 'microwave.enabled', 'microwave.delivered_power_w'], '设置模拟供电，断电保留已发生的热状态。'), + 'thermal.set_temperature': ({'temperature_K': n('K', 273.15, 573.15)}, {'setpoint_K': n('K')}, {'temperature_K': 448.15}, ['controller', 'cavity'], ['thermal.target_k'], '只写目标；温度及热量仅由宿主step推进。'), + 'microwave.set_enabled': ({'enabled': boolean}, {'enabled': boolean}, {'enabled': True}, ['microwave_source', 'cavity'], ['microwave.enabled', 'microwave.delivered_power_w'], '设置理想模拟加热许可；开启需要上电及闭门，不代表已验证厂家互锁。'), + 'microwave.set_power': ({'power_W': n('W', 0, 1500)}, {'power_W': n('W', 0, 1500)}, {'power_W': 1000.0}, ['microwave_source', 'controller'], ['microwave.power_limit_w', 'microwave.delivered_power_w'], '设置理想连续可传递功率上限；额定上限1500 W，不是实际固件接口。'), + 'door.open': ({}, {'angle_rad': n('rad'), 'closed': boolean}, {}, ['door'], ['door.angle_rad', 'door.closed', 'microwave.enabled', 'microwave.delivered_power_w'], '顶门绕场景负X轴上翻90°并撤销模拟加热许可；角度为几何假设。'), + 'door.close': ({}, {'angle_rad': n('rad'), 'closed': boolean}, {}, ['door'], ['door.angle_rad', 'door.closed'], '关闭顶门；关闭后不自动恢复加热许可。'), + 'rack.set_slot': ({'slot_index': {'type': 'integer', 'minimum': 0, 'maximum': 23, 'x-unit': '1'}, 'occupied': boolean}, {'slot_index': {'type': 'integer', 'minimum': 0, 'maximum': 23, 'x-unit': '1'}, 'occupied': boolean}, {'slot_index': 0, 'occupied': True}, ['rack'], ['rack.occupied_slots'], '仅配置24槽场景占位；没有样品质量、加液、物质转移或酸消解。'), + } + caps = {} + for cap, (args, output, example, components, immediate, meaning) in defs.items(): + pre = [] + if cap in ('thermal.set_temperature', 'microwave.set_power'): + pre.append({'description_zh': '模拟供电开启。', 'state_ids': ['power.enabled'], 'enforced_by': 'adapter', 'check': 'power.enabled'}) + if cap == 'thermal.set_temperature': + pre.append({'description_zh': '设定值不低于宿主环境温度。', 'state_ids': [], 'enforced_by': 'adapter', 'check': 'ambient_temperature_K <= temperature_K <= 573.15'}) + if cap == 'microwave.set_enabled': + pre.append({'description_zh': '开启需要供电及闭门；仅模拟前提。', 'state_ids': ['power.enabled', 'door.closed'], 'enforced_by': 'adapter', 'check': 'not enabled or (power.enabled and door.closed)'}) + scene_required = cap.startswith('door.') or cap == 'rack.set_slot' + if scene_required: + pre.append({'description_zh': '已注册同步场景回调。', 'state_ids': [], 'enforced_by': 'adapter', 'check': 'scene_adapter is not None'}) + if cap == 'rack.set_slot': + pre.append({'description_zh': '门打开且加热关闭；只修改可视占位。', 'state_ids': ['door.closed', 'microwave.enabled'], 'enforced_by': 'adapter', 'check': 'not door.closed and not microwave.enabled'}) + effects = [{'state_id': sid, 'timing': 'immediate', 'description_zh': meaning} for sid in immediate] + if cap != 'rack.set_slot': + effects += [{'state_id': sid, 'timing': 'on_step', 'description_zh': '有限功率单节点热响应和累计能量；只由宿主推进。'} for sid in ('thermal.temperature_k', 'thermal.indicated_temperature_k', 'microwave.delivered_power_w', 'thermal.absorbed_energy_j', 'thermal.environment_energy_j', 'thermal.stored_energy_change_j')] + caps[cap] = {'availability': 'implemented', 'visibility': 'agent', 'kind': 'configuration' if cap == 'rack.set_slot' else 'device_command', + 'description_zh': meaning, 'component_ids': components, 'input_schema': _multiwave_object(args), 'output_schema': _multiwave_object(output), + 'example_arguments': [example], 'observes': immediate, 'state_effects': effects, 'preconditions': pre, 'scene_backend_required': scene_required, + 'binding': f"basic40_runtime_thermal.Multiwave7101Session.invoke(instance_id=..., capability_id='{cap}', arguments=..., request_id=...)", + 'completion_criterion_zh': '同步成功只确认设定/场景动作提交；达到温度必须由后续宿主step和显示读数确认。'} + unsupported = {} + for cap, why in {'pressure.set_limit': '未取得24×8 mL架型压力限值；禁止以整机压力替代。', 'chemistry.digest': '无酸消解动力学、压力或物质模���。', 'hardware.connect': '无真实仪器驱动。', 'robot.transfer': '无机器人抓取或液体转移执行。'}.items(): + unsupported[cap] = {'availability': 'unsupported', 'visibility': 'agent', 'kind': 'device_command', 'description_zh': why, + 'component_ids': ['rack'] if cap.startswith('pressure.') else ['housing'], 'input_schema': _multiwave_object({}), 'output_schema': _multiwave_object({}), + 'example_arguments': [{}], 'state_effects': [], 'observes': [], 'preconditions': [], 'binding': None, 'scene_backend_required': False} + def p(value, unit, evidence, source): return {'value': value, 'unit': unit, 'evidence': evidence, 'source': source} + params = { + 'transferable_power_W': p(1500.0, 'W', 'public_document', MULTIWAVE_7101_SOURCE), + 'installed_power_W': p(2000.0, 'W', 'public_document', MULTIWAVE_7101_SOURCE), + 'maximum_temperature_K': p(573.15, 'K', 'public_document', MULTIWAVE_7101_SOURCE), + 'slot_count': p(24, '1', 'catalogue', 'Specified 24 x 8 mL rack'), + 'slot_capacity_m3': p(8e-6, 'm^3', 'catalogue', '8 mL x 1e-6 m^3/mL'), + 'rack_pressure_limit_Pa': p(None, 'Pa', 'unknown', 'Rack-specific limit unavailable; whole-instrument pressure is not substituted.'), + 'thermal_capacity_J_K': p(MULTIWAVE_7101_CAPACITY_J_K, 'J/K', 'derived_estimate', 'C=-UA*330/ln(1-UA*150/1000), with assumed absorbed1000W, ambient298.15K and UA1W/K. Not measured or identifiable from the published time alone.'), + 'heat_loss_W_K': p(1.0, 'W/K', 'assumption', 'Closed-vessel one-node UA; no measured cooldown calibration.'), + 'open_extra_loss_W_K': p(5.0, 'W/K', 'assumption', 'Illustrative passive open-door extra UA, not factory active cooling.'), + 'reference_absorbed_power_W': p(1000.0, 'W', 'assumption', 'Assumed thermal input; reference says <55% of2000W installed input. Transfer efficiency is not measured.'), + 'reference_heatup_time_s': p(330.0, 's', 'public_document', MULTIWAVE_7101_SOURCE + ' PDF page5; 175degC in5.5min, <55%installed power across7101/7301/7501.'), + 'factory_ramp_rate_K_s': p(None, 'K/s', 'unknown', 'No7101 ramp rating established; 70degC/min statement is specific to7301 and is not reused.'), + 'factory_cooldown_time_s': p(None, 's', 'unknown', 'Not calibrated to a7101/rack-specific cooldown benchmark.'), + } + return {'asset_types': {MULTIWAVE_7101_TYPE: {'catalog_id': 'CHEM-047', 'model': 'Anton Paar Multiwave 7101, 24 x 8 mL rack', 'asset_version': '1.0.0', 'state_slots': slots, 'capabilities': caps, 'declared_capabilities': unsupported, 'parameters': params}}, + 'host_capabilities': {'sim.step': {'kind': 'simulation', 'visibility': 'trusted_host_only', 'input_schema': _multiwave_object({'dt_s': n('s', 0, 86400)}), 'binding': 'Multiwave7101Runtime.step(dt_s)', 'partial_failure': 'Clock/process commit before callbacks; synchronization failure may leave partially updated scene.'}}, + 'trusted_scene_callback': 'scene_adapter(instance_id,updates): full public scene snapshot; door.angle_rad maps about negativeX; rack.occupied_slots holds24 visual flags; no process_truth is passed.', + 'result_schema_scope': 'capability.output_schema validates response.result only', + 'limitations': ['Thermal node is an illustrative loaded-system surrogate, not sample/acid thermodynamics, boiling, pressure or digestion kinetics.', 'C inferred using assumed absorbed power and UA; published heatup constrains but does not identify these quantities. No measured calibration claim.', 'Empty/occupied visual slots do not alter synthetic thermal capacity or represent liquid transfer.', 'Temperature display is ideal rounded0.1degC, quality=estimated; no real sensor model.', 'Door inhibit is a simulation precondition, not verified physical interlock or pressure-release safety.', 'Passive cooling only; no measured active-cooling performance.', 'API access filtering is not a Python/process/filesystem sandbox; host/debug artifacts must remain trusted.', 'No hardware/robot execution, restart-persistent deduplication, pressure or chemical safety claims.']} + + +def multiwave_7101_calibration_report(): + c = MULTIWAVE_7101_CAPACITY_J_K + def time_to(target, power): + return -c / MULTIWAVE_7101_LOSS_W_K * math.log1p(-MULTIWAVE_7101_LOSS_W_K * (target - MULTIWAVE_7101_AMBIENT_K) / power) + return {'catalog_id': 'CHEM-047', 'evidence_status': 'manufacturer_time_constrained_illustrative_parameterization', + 'is_measured_calibration': False, 'source': MULTIWAVE_7101_SOURCE, 'source_pdf_page': 5, + 'source_heatup_temperature_K': 448.15, 'source_heatup_time_s': 330.0, 'source_installed_power_W': 2000.0, 'source_power_fraction_upper_bound': .55, + 'source_ambient_temperature_K': None, 'source_absorbed_power_W': None, + 'assumed_ambient_temperature_K': 298.15, 'assumed_reference_absorbed_power_W': 1000.0, + 'assumed_UA_W_K': 1.0, 'inferred_effective_C_J_K': c, 'rated_transferable_power_W': 1500.0, + 'inference_equation': 'C=-UA*t/log(1-UA*(Tref-Ta)/P_assumed); P_input and P_absorbed are not interchangeable without an efficiency assumption.', + 'reference_175C_at_assumed1000W_s': time_to(448.15, 1000.0), 'prediction_175C_at1500W_s': time_to(448.15, 1500.0), + 'prediction_300C_at1500W_s': time_to(573.15, 1500.0), 'prediction_initial_full_power_K_s': 1500.0 / c, + 'predicted_closed_passive_half_cooling_s': c * math.log(2), + 'whole_instrument_mass_used_as_thermal_capacity': False, 'rack_pressure_limit_Pa': None, 'factory_ramp_K_s': None, + 'factory_cooling_validation': 'not_run; no rack-specific benchmark used', + 'assumptions': ['Single well-mixed effective thermal node; properties constant from ambient to300degC.', 'UA=1W/K and absorbed1000W are unmeasured choices, not uniquely fitted values.', 'Assumed reference absorbed power is below1100W installed-input upper bound; actual conversion efficiency remains unknown.', 'No pressure, phase transition, chemistry, vessel mass allocation or loaded-rack safety inference.', 'Extra open-door passive loss5W/K is unmeasured; no active cooling curve.']} + + +class Multiwave7101Runtime: + """Trusted shared-clock host. Expose a session, never host/debug internals.""" + def __init__(self, *, ambient_temperature_K=MULTIWAVE_7101_AMBIENT_K, scene_adapter=None): + if not _number(ambient_temperature_K) or not 273.15 <= ambient_temperature_K <= 313.15: + raise ValueError('Ambient must be finite within the assumed273.15..313.15K envelope') + if scene_adapter is not None and not callable(scene_adapter): raise ValueError('Scene adapter must be callable') + self.ambient_temperature_K = float(ambient_temperature_K) + self.scene_adapter, self.time_s = scene_adapter, 0.0 + self._instances, self._requests, self._scene_faults = {}, {}, [] + self._principals, self._logs = {'__public_agent__': ('agent', None)}, {'__public_agent__': []} + self._metadata, self._lock = export_multiwave_7101_metadata(), threading.RLock() + self._agent = Multiwave7101Session(self, '__public_agent__') + + def _scene_payload(self, state): + fields = ('door.angle_rad', 'rack.occupied_slots', 'thermal.indicated_temperature_k', 'thermal.target_k', 'power.enabled', 'microwave.enabled', 'microwave.delivered_power_w') + return {sid: copy.deepcopy(state[sid]) for sid in fields} + + def create_instance(self, instance_id, asset_type_id=MULTIWAVE_7101_TYPE): + with self._lock: + if not isinstance(instance_id, str) or not instance_id or instance_id in self._instances or asset_type_id != MULTIWAVE_7101_TYPE: + raise ValueError('Unique nonempty instance ID and declared Multiwave7101 type required') + state = {'power.enabled': False, 'thermal.target_k': self.ambient_temperature_K, 'thermal.temperature_k': self.ambient_temperature_K, + 'thermal.indicated_temperature_k': round(self.ambient_temperature_K - 273.15, 1) + 273.15, + 'microwave.enabled': False, 'microwave.power_limit_w': 1500.0, 'microwave.delivered_power_w': 0.0, + 'door.angle_rad': 0.0, 'door.closed': True, 'rack.occupied_slots': [False] * 24, + 'rack.slot_count': 24, 'rack.slot_capacity_m3': 8e-6, 'rack.pressure_limit_pa': None, + 'thermal.absorbed_energy_j': 0.0, 'thermal.environment_energy_j': 0.0, 'thermal.stored_energy_change_j': 0.0} + if self.scene_adapter: self.scene_adapter(instance_id, self._scene_payload(state)) + self._instances[instance_id] = {'state': state, 'revision': 0} + + def register_principal(self, principal_id, *, visibility, instance_ids=None): + with self._lock: + if not isinstance(principal_id, str) or not principal_id or principal_id in self._principals or visibility not in ('agent', 'debug', 'evaluator'): + raise ValueError('Invalid or duplicate host identity') + if instance_ids is not None and (not isinstance(instance_ids, (list, tuple, set, frozenset)) or any(not isinstance(sid, str) for sid in instance_ids)): + raise ValueError('Identity scope must be an explicit collection of instance IDs') + scope = None if instance_ids is None else frozenset(instance_ids) + if scope is not None and not scope <= self._instances.keys(): raise ValueError('Unknown identity scope') + self._principals[principal_id], self._logs[principal_id] = (visibility, scope), [] + + def session(self, principal_id): + with self._lock: + if not isinstance(principal_id, str) or principal_id not in self._principals: raise ValueError('Host registration required') + return Multiwave7101Session(self, principal_id) + + def describe(self, **kwargs): return self._agent.describe(**kwargs) + def read(self, **kwargs): return self._agent.read(**kwargs) + def invoke(self, **kwargs): return self._agent.invoke(**kwargs) + def write(self, **kwargs): return self._agent.write(**kwargs) + def describe_host(self): return copy.deepcopy(self._metadata['host_capabilities']) + + def debug_snapshot(self): + with self._lock: return copy.deepcopy({'time_s': self.time_s, 'instances': self._instances, 'scene_faults': self._scene_faults}) + + def sync_scene(self, instance_ids=None): + with self._lock: + if self.scene_adapter is None: raise RuntimeError('No scene adapter registered') + ids = list(self._instances) if instance_ids is None else list(instance_ids) + if any(sid not in self._instances for sid in ids): raise ValueError('Unknown instance') + for sid in ids: + try: self.scene_adapter(sid, self._scene_payload(self._instances[sid]['state'])) + except Exception: raise SceneSynchronizationError('Scene synchronization failed; scene may have partial effects') from None + + def _delivered(self, state): + if not state['power.enabled'] or not state['microwave.enabled'] or not state['door.closed']: return 0.0 + t, target, p = state['thermal.temperature_k'], state['thermal.target_k'], state['microwave.power_limit_w'] + if t > target + 1e-10: return 0.0 + if t < target - 1e-10: return p + return min(p, MULTIWAVE_7101_LOSS_W_K * max(0.0, target - self.ambient_temperature_K)) + + def _advance(self, state, dt): + ambient, c = self.ambient_temperature_K, MULTIWAVE_7101_CAPACITY_J_K + ua = MULTIWAVE_7101_LOSS_W_K + (0.0 if state['door.closed'] else MULTIWAVE_7101_OPEN_LOSS_W_K) + old, target = state['thermal.temperature_k'], state['thermal.target_k'] + p = state['microwave.power_limit_w'] if state['power.enabled'] and state['microwave.enabled'] and state['door.closed'] else 0.0 + current, remaining, absorbed = old, dt, 0.0 + if current > target: + crossing = c / ua * math.log((current - ambient) / (target - ambient)) if target > ambient else math.inf + h = min(remaining, crossing) + current = ambient + (current - ambient) * math.exp(-ua * h / c) + remaining -= h + if crossing <= h: current = target + if remaining > 0: + equilibrium = ambient + p / ua + if p > 0 and equilibrium >= target and current <= target: + crossing = 0.0 if current == target else (c / ua * math.log((equilibrium - current) / (equilibrium - target)) if equilibrium > target else math.inf) + h = min(remaining, crossing) + current = equilibrium + (current - equilibrium) * math.exp(-ua * h / c) + absorbed += p * h + if crossing <= h: + current = target + absorbed += ua * (target - ambient) * (remaining - h) + else: + current = equilibrium + (current - equilibrium) * math.exp(-ua * remaining / c) + absorbed += p * remaining + current = min(MULTIWAVE_7101_MAX_K, max(ambient, current)) + delta_energy = c * (current - old) + state['thermal.temperature_k'] = current + state['thermal.indicated_temperature_k'] = round(current - 273.15, 1) + 273.15 + state['thermal.absorbed_energy_j'] += absorbed + state['thermal.environment_energy_j'] += absorbed - delta_energy + state['thermal.stored_energy_change_j'] = c * (current - ambient) + state['microwave.delivered_power_w'] = self._delivered(state) + + def step(self, dt_s): + if not _number(dt_s) or not 0 <= dt_s <= 86400: raise ValueError('Host step must be finite within0..86400s') + if dt_s == 0: return + with self._lock: + for inst in self._instances.values(): + self._advance(inst['state'], float(dt_s)) + inst['revision'] += 1 + self.time_s += float(dt_s) + if self.scene_adapter: + failed = [] + for sid, inst in self._instances.items(): + try: self.scene_adapter(sid, self._scene_payload(inst['state'])) + except Exception: + failed.append(sid) + self._scene_faults.append({'instance_id': sid, 'time_s': self.time_s, 'code': 'SCENE_SYNCHRONIZATION_FAILED', 'side_effects': 'partial_or_unknown'}) + if failed: raise SceneSynchronizationError('Shared clock/process advanced; scene synchronization failed with possible partial effects') from None + + +class Multiwave7101Session: + """Capability-limited interface; caller cannot supply a role or clock step.""" + def __init__(self, host, principal_id): self.__host, self.__principal = host, principal_id + def _visible(self, info): return info['visibility'] == 'agent' or self.__host._principals[self.__principal][0] in ('debug', 'evaluator') + def _instance(self, sid): + if not isinstance(sid, str): return None + scope = self.__host._principals[self.__principal][1] + return self.__host._instances.get(sid) if scope is None or sid in scope else None + def _envelope(self, sid, request_id=None, *, result=None, observations=None, status='succeeded', error=None): + inst = self._instance(sid) + return {'protocol_version': PROTOCOL_VERSION, 'instance_id': sid if isinstance(sid, str) else None, 'request_id': request_id if isinstance(request_id, str) else None, + 'operation_id': None, 'status': status, 'state_revision': inst['revision'] if inst else None, 'clock': {'domain': 'simulation', 'time_s': self.__host.time_s}, + 'result': copy.deepcopy(result or {}), 'observations': copy.deepcopy(observations or {}), 'error': error} + def _error(self, sid, code, request_id=None, status='rejected'): + messages = {'UNKNOWN_INSTANCE': 'Instance unavailable.', 'UNKNOWN_CAPABILITY': 'Capability unavailable.', 'INVALID_ARGUMENT': 'Arguments violate schema or bounds.', + 'ACCESS_DENIED': 'Request outside session policy.', 'PRECONDITION_FAILED': 'Required simulation state unavailable.', 'REQUEST_CONFLICT': 'Request ID belongs to different arguments.', + 'UNSUPPORTED': 'Execution unavailable in this adapter.', 'DEVICE_ERROR': 'Scene callback did not complete command.'} + return self._envelope(sid, request_id, status=status, error={'code': code, 'message': messages[code], 'retryable': False, 'side_effects': 'unknown' if code == 'DEVICE_ERROR' else 'none', 'progress': None}) + + def describe(self, *, asset_type_id=None, instance_id=None): + host = self.__host + with host._lock: + if (asset_type_id is None) == (instance_id is None): return self._error(None, 'INVALID_ARGUMENT') + if instance_id is not None and not self._instance(instance_id): return self._error(instance_id, 'UNKNOWN_INSTANCE') + if asset_type_id is not None and asset_type_id != MULTIWAVE_7101_TYPE: return self._error(None, 'INVALID_ARGUMENT') + if host._principals[self.__principal][1] == frozenset(): return self._error(instance_id, 'ACCESS_DENIED') + spec = copy.deepcopy(host._metadata['asset_types'][MULTIWAVE_7101_TYPE]) + spec['state_slots'] = {sid: info for sid, info in spec['state_slots'].items() if self._visible(info)} + spec['capabilities'].update(spec.pop('declared_capabilities')) + for cap in spec['capabilities'].values(): + cap['state_effects'] = [e for e in cap['state_effects'] if e['state_id'] in spec['state_slots']] + cap['observes'] = [sid for sid in cap['observes'] if sid in spec['state_slots']] + if cap.get('scene_backend_required') and host.scene_adapter is None: cap['availability'] = 'unsupported' + return {'protocol_version': PROTOCOL_VERSION, 'asset_type_id': MULTIWAVE_7101_TYPE, 'instance_id': instance_id, + 'adapter': 'basic40_runtime_thermal.Multiwave7101Session', **spec, 'limitations': copy.deepcopy(host._metadata['limitations'])} + + def read(self, *, instance_id, state_ids=None): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if not inst: return self._error(instance_id, 'UNKNOWN_INSTANCE') + slots = host._metadata['asset_types'][MULTIWAVE_7101_TYPE]['state_slots'] + if state_ids is None: state_ids = [sid for sid, info in slots.items() if self._visible(info)] + if not isinstance(state_ids, list) or any(not isinstance(sid, str) for sid in state_ids) or len(set(state_ids)) != len(state_ids): return self._error(instance_id, 'INVALID_ARGUMENT') + if any(sid not in slots or not self._visible(slots[sid]) for sid in state_ids): return self._error(instance_id, 'ACCESS_DENIED') + obs = {sid: {'value': copy.deepcopy(inst['state'][sid]), 'unit': slots[sid]['unit'], 'quality': 'unavailable' if inst['state'][sid] is None else ('estimated' if slots[sid]['origin'] == 'derived' else 'valid'), 'sample_time_s': host.time_s, 'sample_window_s': None} for sid in state_ids} + return self._envelope(instance_id, observations=obs) + + def invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if not inst: return self._error(instance_id, 'UNKNOWN_INSTANCE', request_id) + if not isinstance(capability_id, str) or not isinstance(arguments, dict) or not isinstance(request_id, str) or not request_id or len(request_id) > 256: + return self._error(instance_id, 'INVALID_ARGUMENT', request_id) + try: digest = hashlib.sha256(json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False).encode()).hexdigest() + except (TypeError, ValueError, OverflowError): return self._error(instance_id, 'INVALID_ARGUMENT', request_id) + key = (self.__principal, instance_id, request_id) + if key in host._requests: + old_digest, response = host._requests[key] + return copy.deepcopy(response) if digest == old_digest else self._error(instance_id, 'REQUEST_CONFLICT', request_id) + response = self._checked(instance_id, inst, capability_id, arguments, request_id) + host._requests[key] = (digest, copy.deepcopy(response)) + host._logs[self.__principal].append({'instance_id': instance_id, 'capability_id': capability_id, 'request_id': request_id, 'response': copy.deepcopy(response)}) + return response + + def _checked(self, sid, inst, cap, args, request_id): + host, old = self.__host, inst['state'] + spec = host._metadata['asset_types'][MULTIWAVE_7101_TYPE] + fail = lambda code, status='rejected': self._error(sid, code, request_id, status) + if cap in spec['declared_capabilities']: return fail('UNSUPPORTED', 'unsupported') + if cap not in spec['capabilities']: return fail('UNKNOWN_CAPABILITY') + if set(args) != set(spec['capabilities'][cap]['input_schema']['properties']): return fail('INVALID_ARGUMENT') + if cap in ('power.set', 'microwave.set_enabled') and type(args['enabled']) is not bool: return fail('INVALID_ARGUMENT') + if cap == 'thermal.set_temperature' and (not _number(args['temperature_K']) or not host.ambient_temperature_K <= args['temperature_K'] <= MULTIWAVE_7101_MAX_K): return fail('INVALID_ARGUMENT') + if cap == 'microwave.set_power' and (not _number(args['power_W']) or not 0 <= args['power_W'] <= 1500): return fail('INVALID_ARGUMENT') + if cap == 'rack.set_slot' and (type(args['slot_index']) is not int or not 0 <= args['slot_index'] <= 23 or type(args['occupied']) is not bool): return fail('INVALID_ARGUMENT') + if cap in ('thermal.set_temperature', 'microwave.set_power') and not old['power.enabled']: return fail('PRECONDITION_FAILED') + if cap == 'microwave.set_enabled' and args['enabled'] and not (old['power.enabled'] and old['door.closed']): return fail('PRECONDITION_FAILED') + if spec['capabilities'][cap]['scene_backend_required'] and host.scene_adapter is None: return fail('UNSUPPORTED', 'unsupported') + if cap == 'rack.set_slot' and (old['door.closed'] or old['microwave.enabled']): return fail('PRECONDITION_FAILED') + state = copy.deepcopy(old) + if cap == 'power.set': + state['power.enabled'] = args['enabled'] + if not args['enabled']: state['microwave.enabled'] = False + state['microwave.delivered_power_w'] = host._delivered(state) + result = {'enabled': args['enabled']} + elif cap == 'thermal.set_temperature': + state['thermal.target_k'] = float(args['temperature_K']) + result = {'setpoint_K': state['thermal.target_k']} + elif cap == 'microwave.set_enabled': + state['microwave.enabled'] = args['enabled'] + state['microwave.delivered_power_w'] = host._delivered(state) + result = {'enabled': args['enabled']} + elif cap == 'microwave.set_power': + state['microwave.power_limit_w'] = float(args['power_W']) + state['microwave.delivered_power_w'] = host._delivered(state) + result = {'power_W': state['microwave.power_limit_w']} + elif cap.startswith('door.'): + closed = cap == 'door.close' + state['door.angle_rad'], state['door.closed'] = (0.0 if closed else math.pi / 2), closed + if not closed: + state['microwave.enabled'] = False + state['microwave.delivered_power_w'] = 0.0 + result = {'angle_rad': state['door.angle_rad'], 'closed': closed} + else: + state['rack.occupied_slots'][args['slot_index']] = args['occupied'] + result = {'slot_index': args['slot_index'], 'occupied': args['occupied']} + if state != old: + if host.scene_adapter: + try: host.scene_adapter(sid, host._scene_payload(state)) + except Exception: return fail('DEVICE_ERROR', 'failed') + inst['state'], inst['revision'] = state, inst['revision'] + 1 + return self._envelope(sid, request_id, result=result) + + def write(self, *, instance_id, state_id, value, request_id): + with self.__host._lock: + if not self._instance(instance_id): return self._error(instance_id, 'UNKNOWN_INSTANCE', request_id) + slots = self.__host._metadata['asset_types'][MULTIWAVE_7101_TYPE]['state_slots'] + slot = slots.get(state_id) if isinstance(state_id, str) else None + if slot is None or not self._visible(slot) or slot['access'] != 'read_write': return self._error(instance_id, 'ACCESS_DENIED', request_id) + route = slot['write_via'] + return self.invoke(instance_id=instance_id, capability_id=route['capability_id'], arguments={route['parameter']: value}, request_id=request_id) + + def logs(self): + with self.__host._lock: return copy.deepcopy(self.__host._logs[self.__principal]) +# END CHEM-047 Anton Paar Multiwave 7101 runtime. + + +def validate_miele_plw6111_runtime(output_directory=None): + """Run this asset's actual tests and emit reproducible, layer-specific evidence.""" + import sys as _miele_sys + import time as _miele_time + root = Path(__file__).resolve().parents[1] + for entry in (root / 'scripts', root / 'tests', root / 'skills/chemistry-lab-assets/scripts'): + if str(entry) not in _miele_sys.path: _miele_sys.path.insert(0, str(entry)) + import test_basic40_thermal as _miele_test_module + stream = io.StringIO() + passed = [] + class MieleEvidenceResult(unittest.TextTestResult): + def addSuccess(self, test): + passed.append(test.id().split('.')[-1]) + super().addSuccess(test) + suite = unittest.defaultTestLoader.loadTestsFromTestCase(_miele_test_module.MielePLW6111RuntimeTests) + start = _miele_time.perf_counter() + result = unittest.TextTestRunner(stream=stream, verbosity=2, resultclass=MieleEvidenceResult).run(suite) + metadata = export_miele_plw6111_metadata() + all_caps = list(metadata['asset_types'][MIELE_PLW6111_TYPE]['capabilities']) + checks = [] + for name in passed: + if any(token in name for token in ('truth_filter', 'double_instance', 'request_replay', 'invalid_step', 'time_partition')): layer = 'host' + else: layer = 'process' + if 'three_basket' in name or 'scene_backend' in name: caps = ['door.open', 'door.close', 'basket.set_position'] + elif 'set_temperature' in name: caps = ['thermal.set_temperature'] + elif any(token in name for token in ('phase_order', 'loss_analytic', '7500w', 'zero_dry', 'unreachable', 'unknown_water')): caps = ['washing.start', 'washing.configure_program'] + elif 'stop_retains' in name: caps = ['washing.stop', 'power.set'] + else: caps = all_caps + checks.append({'id': name, 'layer': layer, 'capability_ids': caps, 'status': 'passed', 'method': 'unittest test_basic40_thermal.MielePLW6111RuntimeTests.' + name, + 'note': 'Executed assertion-based synthetic test; scene callbacks here are test doubles, not Blender pose verification. No manufacturer calibration or hardware validation claimed.'}) + report = {'catalog_id': 'CHEM-191', 'asset_type_id': MIELE_PLW6111_TYPE, 'status': 'passed' if result.wasSuccessful() else 'failed', + 'checked_at': datetime.now(timezone.utc).isoformat(), 'environment': {'python': platform.python_version(), 'platform': platform.platform(), 'bytecode_disabled': bool(_miele_sys.dont_write_bytecode), 'runtime': 'CPython synthetic host runtime; scene test doubles'}, + 'tests_run': result.testsRun, 'elapsed_s': _miele_time.perf_counter() - start, 'failures': [{'test': str(test), 'detail': detail} for test, detail in result.failures + result.errors], 'checks': checks, + 'implementation_validation': {'process': 'passed', 'host': 'passed', 'scene': 'not_run', 'robot': 'not_run', 'hardware': 'not_run'}, + 'source_sha256': {'scripts/basic40_runtime_thermal.py': hashlib.sha256(Path(__file__).read_bytes()).hexdigest(), 'tests/test_basic40_thermal.py': hashlib.sha256((root / 'tests/test_basic40_thermal.py').read_bytes()).hexdigest()}, + 'synthetic_heatup_reference': {'evidence': 'assumption, only used in synthetic tests; not a manufacturer default or calibrated performance', 'effective_water_mass_kg': 10, 'water_specific_heat_J_kg_K': 4180, 'effective_heat_capacity_J_K': 41800, 'heat_loss_W_K': 0, 'initial_temperature_K': 293.15, 'target_temperature_K': 333.15, 'water_heater_power_W': 7500, 'predicted_heatup_s': 41800 * 40 / 7500, 'formula': 't=C*(Ttarget-Tinitial)/P when UA=0'}, + 'manufacturer_comparison': 'not_run: exact product heater rating is known, but manufacturer water charge, heat-up time and loss calibration are unavailable; no claim of matching cycle duration or heating performance.', + 'boundaries': metadata['limitations']} + if output_directory is not None: + output = Path(output_directory) + output.mkdir(parents=True, exist_ok=True) + (output / 'runtime_validation.json').write_text(json.dumps(report, ensure_ascii=False, indent=2) + '\n') + (output / 'runtime_test_log.txt').write_text(stream.getvalue()) + (output / 'runtime_metadata.json').write_text(json.dumps(metadata, ensure_ascii=False, indent=2) + '\n') + return report + +# BEGIN CHEM-018 Parr 4591 runtime (append-only asset scope). +PARR_4591_TYPE = 'instrument.parr_4591' +PARR_4591_POWER_W = 700.0 +PARR_4591_MAX_K = 498.15 +PARR_4591_AMBIENT_PA = 101325.0 # Standard atmosphere assumed by this simulation. +PARR_4591_MAX_GAUGE_PA = 20700000.0 +PARR_4591_MAX_ABSOLUTE_PA = PARR_4591_MAX_GAUGE_PA + PARR_4591_AMBIENT_PA +PARR_4591_VOLUME_M3 = 25e-6 +PARR_4591_MAX_SPEED_RAD_S = 1700 * 2 * math.pi / 60 +PARR_4591_CAPACITY_J_K = 1000.0 # Effective-node assumption; NOT measured factory heat capacity. +PARR_4591_LOSS_W_K = 0.7 # Assumed 20% of 700 W lost at a 200 K temperature excess. +PARR_4591_GAS_R = 8.31446261815324 + + +def export_parr_4591_metadata(): + n, obj = _multiwave_number_schema, _multiwave_object + boolean = {'type': 'boolean'} + def slot(unit, origin, schema, route=None, private=False): + return {'unit': unit, 'origin': origin, 'visibility': 'debug' if private else 'agent', + 'value_schema': schema, 'access': 'read_write' if route else 'read_only', 'write_via': route, + 'reference_conditions': None, 'sampling': {'mode': 'instant', 'time_domain': 'simulation', 'window': None}} + def route(cap, param): return {'capability_id': cap, 'parameter': param} + slots = { + 'power.enabled': slot('1', 'setpoint', boolean, route('power.set', 'enabled')), + 'thermal.target_k': slot('K', 'setpoint', n('K', 273.15, PARR_4591_MAX_K), route('thermal.set_temperature', 'temperature_K')), + 'thermal.temperature_k': slot('K', 'process_truth', n('K'), private=True), + 'thermal.indicated_temperature_k': slot('K', 'derived', n('K')), + 'heater.enabled': slot('1', 'setpoint', boolean, route('heater.set_enabled', 'enabled')), + 'heater.delivered_power_w': slot('W', 'derived', n('W', 0, 700)), + 'pressure.pressure_pa': slot('Pa', 'process_truth', n('Pa', 0), private=True), + 'pressure.indicated_pressure_pa': slot('Pa', 'derived', n('Pa', 0)), + 'pressure.maximum_gauge_pressure_pa': slot('Pa', 'derived', n('Pa', 20700000, 20700000)), + 'vessel.volume_m3': slot('m^3', 'derived', n('m^3', 25e-6, 25e-6)), + 'vessel.seal_material': slot('1', 'derived', {'type': 'string', 'const': 'FKM'}), + 'lid.lift_m': slot('m', 'scene', n('m', 0, .12)), + 'lid.closed': slot('1', 'derived', boolean), + 'vent.open': slot('1', 'setpoint', boolean, route('vent.set_open', 'open')), + 'stirrer.speed_rad_s': slot('rad/s', 'setpoint', n('rad/s', 0, PARR_4591_MAX_SPEED_RAD_S), route('stirrer.set_speed', 'speed_rad_s')), + 'stirrer.angle_rad': slot('rad', 'scene', n('rad', 0, 2*math.pi)), + } + for sid in ('thermal.heater_energy_j', 'thermal.environment_energy_j', 'thermal.stored_energy_change_j'): + slots[sid] = slot('J', 'process_truth', n('J'), private=True) + for sid in ('gas.moles', 'gas.initial_moles', 'gas.exchanged_moles'): + slots[sid] = slot('mol', 'process_truth', n('mol'), private=True) + for sid, info in slots.items(): + info['read_binding'] = f"Parr4591Session.read(instance_id=..., state_ids=['{sid}'])" + if sid.startswith('pressure.'): + info['reference_conditions'] = 'Gauge pressure relative to assumed 101325 Pa atmosphere.' if 'gauge' in sid else 'Absolute pressure; subtract assumed ambient 101325 Pa for gauge pressure.' + if info['origin'] == 'derived': info['observation_note_zh'] = '确定性模拟派生显示或目录常量，quality=estimated；非实测传感器。' + if sid.endswith('_energy_j') or sid.endswith('_moles'): + info['sampling'] = {'mode': 'integral', 'time_domain': 'simulation', 'window': 'Since instance creation; gas balance reference restarts on trusted charge configuration.'} + defs = { + 'power.set': ({'enabled': boolean}, {'enabled': boolean}, {'enabled': True}, ['heater', 'motor'], ['power.enabled', 'heater.enabled', 'heater.delivered_power_w', 'stirrer.speed_rad_s'], '设置模拟供电；断电撤销加热和搅拌但保留热量与气体。'), + 'thermal.set_temperature': ({'temperature_K': n('K', 273.15, 498.15)}, {'setpoint_K': n('K')}, {'temperature_K': 373.15}, ['heater', 'vessel'], ['thermal.target_k'], '仅写入目标；闭釜目标预测压力超过207bar表压时整次拒绝。'), + 'heater.set_enabled': ({'enabled': boolean}, {'enabled': boolean}, {'enabled': True}, ['heater'], ['heater.enabled', 'heater.delivered_power_w'], '供电且闭盖才可允许模拟加热；温度仅宿主step推进。'), + 'stirrer.set_speed': ({'speed_rad_s': n('rad/s', 0, PARR_4591_MAX_SPEED_RAD_S)}, {'speed_rad_s': n('rad/s')}, {'speed_rad_s': 10.0}, ['motor', 'stirrer'], ['stirrer.speed_rad_s'], '设定理想搅拌转速，宿主step积分关节角；不计算混合、扭矩或反应。'), + 'lid.open': ({}, {'lift_m': n('m'), 'closed': boolean}, {}, ['lid', 'vessel'], ['lid.lift_m', 'lid.closed', 'pressure.pressure_pa', 'pressure.indicated_pressure_pa', 'gas.moles', 'gas.exchanged_moles'], '移头式开盖终态示意；须先关闭加热搅拌、冷却及泄压，真实脱驱动和离架流程未实现。'), + 'lid.close': ({}, {'lift_m': n('m'), 'closed': boolean}, {}, ['lid', 'vessel'], ['lid.lift_m', 'lid.closed'], '闭合移头式盖的示意终态，不模拟装架、锁环装配或机器人操作。'), + 'vent.set_open': ({'open': boolean}, {'open': boolean}, {'open': True}, ['vent_valve'], ['vent.open'], '设置理想排气阀；泄压由宿主step有限时间推进，未标定流阻或真实阀门性能。'), + } + caps = {} + process = ['thermal.temperature_k', 'thermal.indicated_temperature_k', 'heater.delivered_power_w', 'pressure.pressure_pa', 'pressure.indicated_pressure_pa', 'gas.moles', 'gas.exchanged_moles', 'thermal.heater_energy_j', 'thermal.environment_energy_j', 'thermal.stored_energy_change_j', 'stirrer.angle_rad'] + for cap,(args,out,example,components,effects,meaning) in defs.items(): + checks = [] + if cap == 'thermal.set_temperature': checks = [('power.enabled', ['power.enabled']), ('ambient_temperature_K <= temperature_K <= 498.15 and forecast_absolute_pressure <= 20801325', ['thermal.target_k'])] + if cap == 'heater.set_enabled': checks = [('not enabled or (power.enabled and lid.closed and forecast_absolute_pressure <= 20801325)', ['power.enabled','lid.closed'])] + if cap == 'stirrer.set_speed': checks = [('speed_rad_s == 0 or (power.enabled and lid.closed)', ['power.enabled','lid.closed'])] + if cap == 'lid.open': checks = [('not heater.enabled and stirrer.speed_rad_s == 0 and temperature <= 323.15 K and abs(pressure-101325 Pa) <= 2000 Pa', ['heater.enabled','stirrer.speed_rad_s'])] + if cap == 'vent.set_open': checks = [('open or forecast_absolute_pressure <= 20801325 Pa', ['vent.open'])] + caps[cap] = {'availability':'implemented', 'visibility':'agent', 'kind':'device_command', 'description_zh':meaning, + 'component_ids':components, 'input_schema':obj(args), 'output_schema':obj(out), 'example_arguments':[example], + 'observes': effects, 'state_effects':[{'state_id':s,'timing':'immediate','description_zh':meaning} for s in effects]+[{'state_id':s,'timing':'on_step','description_zh':'宿主推进有限热响应、理想气体温压关系和场景旋转。'} for s in process], + 'preconditions':[{'description_zh':c,'state_ids':ids,'enforced_by':'adapter','check':c} for c,ids in checks], + 'scene_backend_required':cap.startswith('lid.'), 'binding':f"basic40_runtime_thermal.Parr4591Session.invoke(instance_id=..., capability_id='{cap}', arguments=..., request_id=...)", + 'completion_criterion_zh':'成功只确认设定或场景命令完成；达到温度、泄压与转动须宿主step。'} + unsupported = {cap:{'availability':'unsupported','visibility':'agent','kind':'device_command','description_zh':why, + 'component_ids':['vessel'],'input_schema':obj({}),'output_schema':obj({}),'example_arguments':[{}],'state_effects':[],'observes':[],'preconditions':[],'binding':None,'scene_backend_required':False} + for cap,why in {'chemistry.react':'未实现化学反应、相变、放热或真实气体方程。','hardware.connect':'没有真实硬件驱动。','robot.transfer':'没有机器人抓放或物质转移。'}.items()} + def parameter(value,unit,evidence,source): return {'value':value,'unit':unit,'evidence':evidence,'source':source} + params={ + 'vessel_volume_m3':parameter(25e-6,'m^3','documented','PARR_4590_SPEC; 25 mL'), + 'maximum_gauge_pressure_Pa':parameter(207e5,'Pa','documented','PARR_4590_SPEC; PARR_399M_MANUAL p7 pressure is psig; standard configuration, CE/UKCA 200 bar not selected.'), + 'maximum_temperature_K':parameter(498.15,'K','documented','PARR_4590_SPEC; standard FKM seal 225 deg C'), + 'heater_power_W':parameter(700.0,'W','documented','PARR_4590_SPEC'), + 'thermal_capacity_J_K':parameter(1000.0,'J/K','assumption','Effective-node assumption selected for initial 700/1000 = 0.7 K/s. Order of magnitude considers documented 1.587573295 kg cylinder with assumed steel cp near500 J/kg/K; neither alloy cp nor assembly effective thermal capacity is measured.'), + 'heat_loss_W_K':parameter(.7,'W/K','assumption','Assume 20% of700W lost at200K excess: UA=140/200=.7W/K; power does not uniquely identify C or UA.'), + 'open_extra_loss_W_K':parameter(2.1,'W/K','assumption','Illustrative additional passive loss while open.'), + 'vent_time_constant_s':parameter(15.0,'s','assumption','Illustrative exponential absolute-pressure relaxation to ambient; no valve calibration.'), + 'opening_temperature_K':parameter(323.15,'K','assumption','Simulation-only50degC opening threshold; not a factory interlock or hardware safety advice.'), + 'opening_pressure_tolerance_Pa':parameter(2000.0,'Pa','assumption','Simulation-only2kPa pressure difference opening tolerance.'), + 'lid_travel_m':parameter(.12,'m','assumption','Detached-head illustrative opening pose, not measured travel; required vessel removal from stand is not modeled as a robot operation.'), + 'maximum_speed_rad_s':parameter(PARR_4591_MAX_SPEED_RAD_S,'rad/s','documented','PARR_399M_MANUAL pp20-21 standard1700rpm pulley; continuous0..1700 control range is an assumption.'), + 'ambient_pressure_Pa':parameter(101325.0,'Pa','assumption','Standard atmosphere used to convert gauge pressure to absolute pressure.'), + 'manufacturer_heatup_time_s':parameter(None,'s','unknown','No loaded4591 heatup curve or factory time benchmark validated.'), + } + return {'asset_types':{PARR_4591_TYPE:{'catalog_id':'CHEM-018','model':'Parr4591 moveable head,25mL,standard FKM','asset_version':'1.0.0','state_slots':slots,'capabilities':caps,'declared_capabilities':unsupported,'parameters':params}}, + 'host_capabilities':{'sim.step':{'kind':'simulation','visibility':'trusted_host_only','input_schema':obj({'dt_s':n('s',0,86400)}),'binding':'Parr4591Runtime.step(dt_s)','partial_failure':'Clock/process commit before scene callbacks; callback failure can leave partial scene effects.'}, + 'sim.configure_gas_charge':{'kind':'configuration','visibility':'trusted_host_only','binding':'Parr4591Runtime.configure_gas_charge(instance_id, *, pressure_Pa, evidence)','description_zh':'关闭供电且闭釜闭阀时配置显式惰性理想气体绝压，不代表真实充气；整次校验当前及目标压力上限。'}}, + 'trusted_scene_callback':'scene_adapter(instance_id, updates) receives public fields only: lid.lift_m, lid.closed, stirrer.angle_rad, stirrer.speed_rad_s, vent.open, thermal.indicated_temperature_k, pressure.indicated_pressure_pa, power.enabled, heater.enabled.', + 'result_schema_scope':'capability.output_schema validates envelope.result only', + 'limitations':['25mL is modeled entirely as constant ideal-gas volume; no sample loading, liquid expansion, boiling, dissolved gas, reactions, rupture-disc failure or high-pressure real-gas accuracy.', + 'P_abs=nRT/V;207bar limit is gauge pressure, absolute limit20801325Pa uses assumed101325Pa ambient. No CE/UKCA200bar configuration.', + 'C=1000J/K and UA=.7W/K are explicit effective-node assumptions constrained in scale by700W, not uniquely inferred or manufacturer-calibrated; factory dynamic comparison not_run.', + 'Temperature rounds0.1degC and pressure rounds100Pa, quality=estimated; no measured sensor accuracy.', + 'Opening temperature and pressure conditions are simulation rules, not validated hardware interlocks. Moveable head assumes drive detached and vessel removed; full robot/mechanical opening sequence absent.', + 'Only1700rpm standard pulley endpoint is documented; continuous control, instantaneous speed changes and zero-speed stop are modeled assumptions; no drag/torque/mixing.', + 'Vent15s relaxation is uncalibrated and gas exchange energy is omitted from the effective solid thermal node; no adiabatic blowdown or real vent sizing.', + 'API filtering is not a Python process or filesystem sandbox. Host state and debug records must remain trusted. No persistent deduplication after restart.']} + + +class Parr4591Runtime(Multiwave7101Runtime): + """Trusted host for isolated 4591 instances; inherited generic access/registry helpers only.""" + def __init__(self, *, ambient_temperature_K=298.15, scene_adapter=None): + super().__init__(ambient_temperature_K=ambient_temperature_K, scene_adapter=scene_adapter) + self._metadata = export_parr_4591_metadata() + self._agent = Parr4591Session(self, '__public_agent__') + + def _scene_payload(self, state): + fields = ('lid.lift_m','lid.closed','stirrer.angle_rad','stirrer.speed_rad_s','vent.open','thermal.indicated_temperature_k','pressure.indicated_pressure_pa','power.enabled','heater.enabled') + return {sid:copy.deepcopy(state[sid]) for sid in fields} + + def create_instance(self, instance_id, asset_type_id=PARR_4591_TYPE): + with self._lock: + if not isinstance(instance_id,str) or not instance_id or instance_id in self._instances or asset_type_id != PARR_4591_TYPE: raise ValueError('Unique4591 instance ID required') + t=self.ambient_temperature_K + moles=PARR_4591_AMBIENT_PA*PARR_4591_VOLUME_M3/(PARR_4591_GAS_R*t) + state={'power.enabled':False,'thermal.target_k':t,'thermal.temperature_k':t,'thermal.indicated_temperature_k':round(t-273.15,1)+273.15, + 'heater.enabled':False,'heater.delivered_power_w':0.0,'pressure.pressure_pa':PARR_4591_AMBIENT_PA,'pressure.indicated_pressure_pa':round(PARR_4591_AMBIENT_PA/100)*100.0, + 'pressure.maximum_gauge_pressure_pa':PARR_4591_MAX_GAUGE_PA,'vessel.volume_m3':PARR_4591_VOLUME_M3,'vessel.seal_material':'FKM', + 'lid.lift_m':0.0,'lid.closed':True,'vent.open':False,'stirrer.speed_rad_s':0.0,'stirrer.angle_rad':0.0, + 'gas.moles':moles,'gas.initial_moles':moles,'gas.exchanged_moles':0.0,'thermal.heater_energy_j':0.0,'thermal.environment_energy_j':0.0,'thermal.stored_energy_change_j':0.0} + if self.scene_adapter: + try: self.scene_adapter(instance_id,self._scene_payload(state)) + except Exception: raise RuntimeError('Initial scene callback failed; instance not created; backend effects unknown') from None + self._instances[instance_id]={'state':state,'revision':0} + + def session(self, principal_id): + with self._lock: + if not isinstance(principal_id,str) or principal_id not in self._principals: raise ValueError('Host registration required') + return Parr4591Session(self,principal_id) + + def _forecast_pressure(self, state, target=None): + temperature=max(state['thermal.temperature_k'],state['thermal.target_k'] if target is None else target) + return state['gas.moles']*PARR_4591_GAS_R*temperature/PARR_4591_VOLUME_M3 + + def configure_gas_charge(self, instance_id, *, pressure_Pa, evidence): + with self._lock: + if not isinstance(instance_id,str) or instance_id not in self._instances: raise ValueError('Unknown instance') + if not _number(pressure_Pa) or not PARR_4591_AMBIENT_PA <= pressure_Pa <= PARR_4591_MAX_ABSOLUTE_PA or not isinstance(evidence,str) or not evidence.strip(): raise ValueError('Finite absolute pressure within declared bounds and explicit evidence required') + inst=self._instances[instance_id]; state=copy.deepcopy(inst['state']) + if state['power.enabled'] or not state['lid.closed'] or state['vent.open']: raise ValueError('Charge configuration requires power off, closed lid and closed vent') + moles=pressure_Pa*PARR_4591_VOLUME_M3/(PARR_4591_GAS_R*state['thermal.temperature_k']) + state.update({'gas.moles':moles,'gas.initial_moles':moles,'gas.exchanged_moles':0.0,'pressure.pressure_pa':float(pressure_Pa),'pressure.indicated_pressure_pa':round(pressure_Pa/100)*100.0}) + if self._forecast_pressure(state)>PARR_4591_MAX_ABSOLUTE_PA+1e-6: raise ValueError('Charge and existing target exceed configured pressure envelope') + if self.scene_adapter: + try: self.scene_adapter(instance_id,self._scene_payload(state)) + except Exception: raise RuntimeError('Charge scene callback failed; runtime unchanged; backend effects unknown') from None + inst['state'],inst['revision'],inst['gas_configuration_evidence']=state,inst['revision']+1,evidence + + def _delivered(self,state): + if not state['power.enabled'] or not state['heater.enabled'] or not state['lid.closed']: return 0.0 + t,target=state['thermal.temperature_k'],state['thermal.target_k'] + if t>target+1e-10:return 0.0 + return PARR_4591_POWER_W if ttarget: + crossing=c/ua*math.log((current-ambient)/(target-ambient)) if target>ambient else math.inf + h=min(remaining,crossing);current=ambient+(current-ambient)*math.exp(-ua*h/c);remaining-=h + if crossing<=h:current=target + if remaining>0: + equilibrium=ambient+power/ua + if power>0 and equilibrium>=target and current<=target: + crossing=0.0 if current==target else (c/ua*math.log((equilibrium-current)/(equilibrium-target)) if equilibrium>target else math.inf) + h=min(remaining,crossing);current=equilibrium+(current-equilibrium)*math.exp(-ua*h/c);energy+=power*h + if crossing<=h:current=target;energy+=ua*(target-ambient)*(remaining-h) + else:current=equilibrium+(current-equilibrium)*math.exp(-ua*remaining/c);energy+=power*remaining + current=min(PARR_4591_MAX_K,max(ambient,current)) + state['thermal.temperature_k']=current;state['thermal.indicated_temperature_k']=round(current-273.15,1)+273.15 + state['thermal.heater_energy_j']+=energy;state['thermal.environment_energy_j']+=energy-c*(current-old) + state['thermal.stored_energy_change_j']=c*(current-ambient);state['heater.delivered_power_w']=self._delivered(state) + old_n=state['gas.moles'];pressure=old_n*PARR_4591_GAS_R*current/PARR_4591_VOLUME_M3 + if not state['lid.closed']:pressure=PARR_4591_AMBIENT_PA + elif state['vent.open']:pressure=PARR_4591_AMBIENT_PA+(pressure-PARR_4591_AMBIENT_PA)*math.exp(-dt/15.0) + if pressure>PARR_4591_MAX_ABSOLUTE_PA+1e-6:raise ValueError('Proposed host step exceeds declared pressure limit; no instance or clock committed') + new_n=pressure*PARR_4591_VOLUME_M3/(PARR_4591_GAS_R*current) + if state['vent.open'] or not state['lid.closed']: + state['gas.exchanged_moles']+=new_n-old_n;state['gas.moles']=new_n + state['pressure.pressure_pa']=pressure;state['pressure.indicated_pressure_pa']=round(pressure/100)*100.0 + state['stirrer.angle_rad']=(state['stirrer.angle_rad']+state['stirrer.speed_rad_s']*dt)%(2*math.pi) + + def step(self,dt_s): + if not _number(dt_s) or not 0<=dt_s<=86400:raise ValueError('Host step finite0..86400s required') + if dt_s==0:return + with self._lock: + proposed={sid:copy.deepcopy(inst['state']) for sid,inst in self._instances.items()} + for state in proposed.values():self._advance(state,float(dt_s)) + for sid,state in proposed.items():self._instances[sid]['state']=state;self._instances[sid]['revision']+=1 + self.time_s+=float(dt_s) + failed=False + if self.scene_adapter: + for sid,state in proposed.items(): + try:self.scene_adapter(sid,self._scene_payload(state)) + except Exception: + failed=True;self._scene_faults.append({'instance_id':sid,'time_s':self.time_s,'code':'SCENE_SYNCHRONIZATION_FAILED','side_effects':'partial_or_unknown'}) + if failed:raise SceneSynchronizationError('Clock/process advanced; scene synchronization failed with possible partial scene effects') from None + + +class Parr4591Session: + """Capability-limited interface; caller cannot supply a role or clock step.""" + def __init__(self, host, principal_id): self.__host, self.__principal = host, principal_id + def _visible(self, info): return info['visibility'] == 'agent' or self.__host._principals[self.__principal][0] in ('debug', 'evaluator') + def _instance(self, sid): + if not isinstance(sid, str): return None + scope = self.__host._principals[self.__principal][1] + return self.__host._instances.get(sid) if scope is None or sid in scope else None + def _envelope(self, sid, request_id=None, *, result=None, observations=None, status='succeeded', error=None): + inst = self._instance(sid) + return {'protocol_version': PROTOCOL_VERSION, 'instance_id': sid if isinstance(sid, str) else None, 'request_id': request_id if isinstance(request_id, str) else None, + 'operation_id': None, 'status': status, 'state_revision': inst['revision'] if inst else None, 'clock': {'domain': 'simulation', 'time_s': self.__host.time_s}, + 'result': copy.deepcopy(result or {}), 'observations': copy.deepcopy(observations or {}), 'error': error} + def _error(self, sid, code, request_id=None, status='rejected'): + messages = {'UNKNOWN_INSTANCE': 'Instance unavailable.', 'UNKNOWN_CAPABILITY': 'Capability unavailable.', 'INVALID_ARGUMENT': 'Arguments violate schema or bounds.', + 'ACCESS_DENIED': 'Request outside session policy.', 'PRECONDITION_FAILED': 'Required simulation state unavailable.', 'REQUEST_CONFLICT': 'Request ID belongs to different arguments.', + 'UNSUPPORTED': 'Execution unavailable in this adapter.', 'DEVICE_ERROR': 'Scene callback did not complete command.', 'OVERPRESSURE': 'Proposed operation exceeds configured pressure envelope.'} + return self._envelope(sid, request_id, status=status, error={'code': code, 'message': messages[code], 'retryable': False, 'side_effects': 'unknown' if code == 'DEVICE_ERROR' else 'none', 'progress': None}) + + def describe(self, *, asset_type_id=None, instance_id=None): + host = self.__host + with host._lock: + if (asset_type_id is None) == (instance_id is None): return self._error(None, 'INVALID_ARGUMENT') + if instance_id is not None and not self._instance(instance_id): return self._error(instance_id, 'UNKNOWN_INSTANCE') + if asset_type_id is not None and asset_type_id != PARR_4591_TYPE: return self._error(None, 'INVALID_ARGUMENT') + if host._principals[self.__principal][1] == frozenset(): return self._error(instance_id, 'ACCESS_DENIED') + spec = copy.deepcopy(host._metadata['asset_types'][PARR_4591_TYPE]) + spec['state_slots'] = {sid: info for sid, info in spec['state_slots'].items() if self._visible(info)} + spec['capabilities'].update(spec.pop('declared_capabilities')) + for cap in spec['capabilities'].values(): + cap['state_effects'] = [e for e in cap['state_effects'] if e['state_id'] in spec['state_slots']] + cap['observes'] = [sid for sid in cap['observes'] if sid in spec['state_slots']] + if cap.get('scene_backend_required') and host.scene_adapter is None: cap['availability'] = 'unsupported' + return {'protocol_version': PROTOCOL_VERSION, 'asset_type_id': PARR_4591_TYPE, 'instance_id': instance_id, + 'adapter': 'basic40_runtime_thermal.Parr4591Session', **spec, 'limitations': copy.deepcopy(host._metadata['limitations'])} + + def read(self, *, instance_id, state_ids=None): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if not inst: return self._error(instance_id, 'UNKNOWN_INSTANCE') + slots = host._metadata['asset_types'][PARR_4591_TYPE]['state_slots'] + if state_ids is None: state_ids = [sid for sid, info in slots.items() if self._visible(info)] + if not isinstance(state_ids, list) or any(not isinstance(sid, str) for sid in state_ids) or len(set(state_ids)) != len(state_ids): return self._error(instance_id, 'INVALID_ARGUMENT') + if any(sid not in slots or not self._visible(slots[sid]) for sid in state_ids): return self._error(instance_id, 'ACCESS_DENIED') + obs = {sid: {'value': copy.deepcopy(inst['state'][sid]), 'unit': slots[sid]['unit'], 'quality': 'unavailable' if inst['state'][sid] is None else ('estimated' if slots[sid]['origin'] == 'derived' else 'valid'), 'sample_time_s': host.time_s, 'sample_window_s': None} for sid in state_ids} + return self._envelope(instance_id, observations=obs) + + def invoke(self, *, instance_id, capability_id, arguments, request_id): + host = self.__host + with host._lock: + inst = self._instance(instance_id) + if not inst: return self._error(instance_id, 'UNKNOWN_INSTANCE', request_id) + if not isinstance(capability_id, str) or not isinstance(arguments, dict) or not isinstance(request_id, str) or not request_id or len(request_id) > 256: + return self._error(instance_id, 'INVALID_ARGUMENT', request_id) + try: digest = hashlib.sha256(json.dumps([capability_id, arguments], sort_keys=True, allow_nan=False).encode()).hexdigest() + except (TypeError, ValueError, OverflowError): return self._error(instance_id, 'INVALID_ARGUMENT', request_id) + key = (self.__principal, instance_id, request_id) + if key in host._requests: + old_digest, response = host._requests[key] + return copy.deepcopy(response) if digest == old_digest else self._error(instance_id, 'REQUEST_CONFLICT', request_id) + response = self._checked(instance_id, inst, capability_id, arguments, request_id) + host._requests[key] = (digest, copy.deepcopy(response)) + host._logs[self.__principal].append({'instance_id': instance_id, 'capability_id': capability_id, 'request_id': request_id, 'response': copy.deepcopy(response)}) + return response + + def _checked(self,sid,inst,cap,args,request_id): + host,old=self.__host,inst['state'];spec=host._metadata['asset_types'][PARR_4591_TYPE] + fail=lambda code,status='rejected':self._error(sid,code,request_id,status) + if cap in spec['declared_capabilities']:return fail('UNSUPPORTED','unsupported') + if cap not in spec['capabilities']:return fail('UNKNOWN_CAPABILITY') + if set(args)!=set(spec['capabilities'][cap]['input_schema']['properties']):return fail('INVALID_ARGUMENT') + if cap in ('power.set','heater.set_enabled') and type(args['enabled']) is not bool:return fail('INVALID_ARGUMENT') + if cap=='vent.set_open' and type(args['open']) is not bool:return fail('INVALID_ARGUMENT') + if cap=='thermal.set_temperature' and (not _number(args['temperature_K']) or not host.ambient_temperature_K<=args['temperature_K']<=PARR_4591_MAX_K):return fail('INVALID_ARGUMENT') + if cap=='stirrer.set_speed' and (not _number(args['speed_rad_s']) or not 0<=args['speed_rad_s']<=PARR_4591_MAX_SPEED_RAD_S):return fail('INVALID_ARGUMENT') + if cap=='thermal.set_temperature' and not old['power.enabled']:return fail('PRECONDITION_FAILED') + if cap=='heater.set_enabled' and args['enabled'] and not(old['power.enabled'] and old['lid.closed']):return fail('PRECONDITION_FAILED') + if cap=='stirrer.set_speed' and args['speed_rad_s']>0 and not(old['power.enabled'] and old['lid.closed']):return fail('PRECONDITION_FAILED') + if cap=='lid.open' and (old['heater.enabled'] or old['stirrer.speed_rad_s']!=0 or old['thermal.temperature_k']>323.15 or abs(old['pressure.pressure_pa']-PARR_4591_AMBIENT_PA)>2000):return fail('PRECONDITION_FAILED') + predicts_closed=(cap=='thermal.set_temperature' and old['lid.closed'] and not old['vent.open']) or (cap=='vent.set_open' and not args['open'] and old['lid.closed']) or (cap=='heater.set_enabled' and args['enabled'] and not old['vent.open']) + if predicts_closed and host._forecast_pressure(old,args.get('temperature_K'))>PARR_4591_MAX_ABSOLUTE_PA+1e-6:return fail('OVERPRESSURE') + if spec['capabilities'][cap]['scene_backend_required'] and host.scene_adapter is None:return fail('UNSUPPORTED','unsupported') + state=copy.deepcopy(old) + if cap=='power.set': + state['power.enabled']=args['enabled'] + if not args['enabled']:state['heater.enabled']=False;state['stirrer.speed_rad_s']=0.0 + state['heater.delivered_power_w']=host._delivered(state);result={'enabled':args['enabled']} + elif cap=='thermal.set_temperature':state['thermal.target_k']=float(args['temperature_K']);result={'setpoint_K':state['thermal.target_k']} + elif cap=='heater.set_enabled':state['heater.enabled']=args['enabled'];state['heater.delivered_power_w']=host._delivered(state);result={'enabled':args['enabled']} + elif cap=='stirrer.set_speed':state['stirrer.speed_rad_s']=float(args['speed_rad_s']);result={'speed_rad_s':state['stirrer.speed_rad_s']} + elif cap=='vent.set_open':state['vent.open']=args['open'];result={'open':args['open']} + else: + closed=cap=='lid.close';state['lid.closed']=closed;state['lid.lift_m']=0.0 if closed else .12 + if not closed: + new_n=PARR_4591_AMBIENT_PA*PARR_4591_VOLUME_M3/(PARR_4591_GAS_R*state['thermal.temperature_k']) + state['gas.exchanged_moles']+=new_n-state['gas.moles'];state['gas.moles']=new_n + state['pressure.pressure_pa']=PARR_4591_AMBIENT_PA;state['pressure.indicated_pressure_pa']=round(PARR_4591_AMBIENT_PA/100)*100.0 + result={'lift_m':state['lid.lift_m'],'closed':closed} + if state!=old: + if host.scene_adapter: + try:host.scene_adapter(sid,host._scene_payload(state)) + except Exception:return fail('DEVICE_ERROR','failed') + inst['state'],inst['revision']=state,inst['revision']+1 + return self._envelope(sid,request_id,result=result) + + def write(self, *, instance_id, state_id, value, request_id): + with self.__host._lock: + if not self._instance(instance_id): return self._error(instance_id, 'UNKNOWN_INSTANCE', request_id) + slots = self.__host._metadata['asset_types'][PARR_4591_TYPE]['state_slots'] + slot = slots.get(state_id) if isinstance(state_id, str) else None + if slot is None or not self._visible(slot) or slot['access'] != 'read_write': return self._error(instance_id, 'ACCESS_DENIED', request_id) + route = slot['write_via'] + return self.invoke(instance_id=instance_id, capability_id=route['capability_id'], arguments={route['parameter']: value}, request_id=request_id) + + def logs(self): + with self.__host._lock: return copy.deepcopy(self.__host._logs[self.__principal]) + +# END CHEM-018 Parr 4591 runtime. + +# CHEM-018 append-only correction: integrate gas relaxation along the exact +# temperature trajectory instead of applying vent relaxation at one endpoint. +_Parr4591ThermalBase = Parr4591Runtime + + +class Parr4591Runtime(_Parr4591ThermalBase): + """4591 host with coupled non-isothermal gas exchange and bounded quadrature.""" + def _advance(self, state, dt): + if not (state['lid.closed'] and state['vent.open']): + return super()._advance(state, dt) + original = copy.deepcopy(state) + # Thermal solver is independent of gas contents. Use a harmless trial + # amount for its gas bookkeeping, then replace that bookkeeping below. + state['gas.moles'] = 0.0 + super()._advance(state, dt) + ambient, old = self.ambient_temperature_K, original['thermal.temperature_k'] + target, c, ua, tau = original['thermal.target_k'], PARR_4591_CAPACITY_J_K, PARR_4591_LOSS_W_K, 15.0 + power = PARR_4591_POWER_W if original['power.enabled'] and original['heater.enabled'] else 0.0 + + def temperature_at(elapsed): + current, remaining = old, elapsed + if current > target: + crossing = c / ua * math.log((current - ambient) / (target - ambient)) if target > ambient else math.inf + h = min(remaining, crossing) + current = ambient + (current - ambient) * math.exp(-ua * h / c) + remaining -= h + if crossing <= h: current = target + if remaining > 0: + equilibrium = ambient + power / ua + if power > 0 and equilibrium >= target and current <= target: + crossing = 0.0 if current == target else (c / ua * math.log((equilibrium - current) / (equilibrium - target)) if equilibrium > target else math.inf) + h = min(remaining, crossing) + current = equilibrium + (current - equilibrium) * math.exp(-ua * h / c) + if crossing <= h: current = target + else: + current = equilibrium + (current - equilibrium) * math.exp(-ua * remaining / c) + return min(PARR_4591_MAX_K, max(ambient, current)) + + final_temperature = state['thermal.temperature_k'] + if old == final_temperature: + equilibrium_n = PARR_4591_AMBIENT_PA * PARR_4591_VOLUME_M3 / (PARR_4591_GAS_R * old) + new_n = equilibrium_n + (original['gas.moles'] - equilibrium_n) * math.exp(-dt / tau) + else: + # Exact integrating factor for dn/dt=(n_eq(T(t))-n)/tau. + # Lag x=(dt-t)/tau keeps the exponential well conditioned. The + # omitted x>40 tail is below exp(-40)/273.15 K^-1; adaptive Simpson + # bounds absolute quadrature error at 1e-14 K^-1 per host step. + def integrand(x): return math.exp(-x) / temperature_at(max(0.0, dt - tau * x)) + def simpson(a, b, fa, fm, fb): return (b - a) * (fa + 4 * fm + fb) / 6 + def adaptive(a, b, fa, fm, fb, whole, tolerance, depth): + middle = (a + b) / 2 + fl, fr = integrand((a + middle) / 2), integrand((middle + b) / 2) + left, right = simpson(a, middle, fa, fl, fm), simpson(middle, b, fm, fr, fb) + difference = left + right - whole + if abs(difference) <= 15 * tolerance: + return left + right + difference / 15 + if depth == 0: raise ValueError('Gas quadrature tolerance was not achieved; host state unchanged') + return adaptive(a, middle, fa, fl, fm, left, tolerance / 2, depth - 1) + adaptive(middle, b, fm, fr, fb, right, tolerance / 2, depth - 1) + upper = min(dt / tau, 40.0) + fa, fm, fb = integrand(0.0), integrand(upper / 2), integrand(upper) + integral = adaptive(0.0, upper, fa, fm, fb, simpson(0.0, upper, fa, fm, fb), 1e-14, 24) + new_n = original['gas.moles'] * math.exp(-dt / tau) + PARR_4591_AMBIENT_PA * PARR_4591_VOLUME_M3 / PARR_4591_GAS_R * integral + pressure = new_n * PARR_4591_GAS_R * final_temperature / PARR_4591_VOLUME_M3 + if pressure > PARR_4591_MAX_ABSOLUTE_PA + 1e-6: + raise ValueError('Proposed coupled host step exceeds declared pressure limit; no state committed') + state['gas.moles'] = new_n + state['gas.exchanged_moles'] = original['gas.exchanged_moles'] + new_n - original['gas.moles'] + state['pressure.pressure_pa'] = pressure + state['pressure.indicated_pressure_pa'] = round(pressure / 100) * 100.0 + + +_parr_4591_base_metadata = export_parr_4591_metadata + + +def export_parr_4591_metadata(): + metadata = _parr_4591_base_metadata() + caps = metadata['asset_types'][PARR_4591_TYPE]['capabilities'] + slots = metadata['asset_types'][PARR_4591_TYPE]['state_slots'] + for info in caps.values(): + info['observes'] = [sid for sid in info['observes'] if slots[sid]['visibility'] == 'agent'] + metadata['limitations'].append('Non-isothermal vent model integrates dn/dt=(Pamb*V/(R*T(t))-n)/15s along the exact thermal trajectory. Adaptive Simpson absolute tolerance1e-14 K^-1; exponential tail beyond40 time constants omitted (288.15: return False + source_min=243.15+0.5*(coolant-278.15) if mode=='block' else 253.15 + if target=453.15 and q>0:q=0.0 + if y[i]<=243.15 and q<0:q=0.0 + env=a['block_ambient_conductance_W_K']*(y[i]-ta) + transfer=a['block_liquid_conductance_W_K']*(y[i]-y[4+i]) + cl=a['liquid_density_kg_m3']*a['liquid_specific_heat_J_kg_K']*s[z+'.vessel.fill_volume_m3'] + dy[i]=(q-env-transfer+coupling[i])/cb;dy[4+i]=transfer/cl + dy[8+i]=q;dy[12+i]=env;dy[16+i]=coupling[i] + return dy + def _physics(self,s,h): + y=[s[z+'.thermal.temperature_k'] for z in MYA4_ZONES]+[s[z+'.thermal.liquid_temperature_k'] for z in MYA4_ZONES]+[0.0]*12 + k1=self._derivative(s,y);k2=self._derivative(s,[v+h*k/2 for v,k in zip(y,k1)]);k3=self._derivative(s,[v+h*k/2 for v,k in zip(y,k2)]);k4=self._derivative(s,[v+h*k for v,k in zip(y,k3)]) + result=[v+h*(a+2*b+2*c+d)/6 for v,a,b,c,d in zip(y,k1,k2,k3,k4)] + for i,z in enumerate(MYA4_ZONES): + s[z+'.thermal.temperature_k'],s[z+'.thermal.liquid_temperature_k']=result[i],result[4+i] + for offset,suffix in ((8,'control_energy_j'),(12,'environment_energy_j'),(16,'adjacent_energy_j')):s[z+'.thermal.'+suffix]+=result[offset+i] + def _program(self,s,z,h): + if not s[z+'.program.running']:return + s[z+'.program.reaction_elapsed_s']+=h + idx=s[z+'.program.segment_index'];seg=s[z+'.program.segments'][idx] + feedback=s[z+'.thermal.temperature_k'] if s[z+'.thermal.probe_mode']=='block' else s[z+'.thermal.liquid_temperature_k'] + if abs(feedback-seg['temperature_K'])<=MYA4_ASSUMPTIONS['program_arrival_tolerance_K']: + s[z+'.program.phase']='holding';s[z+'.program.hold_elapsed_s']+=h + if s[z+'.program.hold_elapsed_s']+1e-10>=seg['hold_s']: + s[z+'.program.hold_elapsed_s']=seg['hold_s'];idx+=1;s[z+'.program.segment_index']=idx + if idx==len(s[z+'.program.segments']):s[z+'.program.running'],s[z+'.program.phase'],s[z+'.thermal.enabled']=False,'completed',False + else: + next_target=s[z+'.program.segments'][idx]['temperature_K'] + if not self._target_valid(s,z,next_target,s[z+'.thermal.probe_mode']): + s[z+'.program.running'],s[z+'.program.phase'],s[z+'.thermal.enabled']=False,'stopped',False + else:s[z+'.thermal.target_k'],s[z+'.program.hold_elapsed_s'],s[z+'.program.phase']=next_target,0.0,'approaching' + else:s[z+'.program.phase']='approaching' + def step(self,dt_s): + if not _number(dt_s) or not 0<=dt_s<=86400:raise ValueError('Host step must be finite0..86400s') + if dt_s==0:return + with self._lock: + for inst in self._instances.values(): + s=inst['state'];remaining=float(dt_s) + while remaining>1e-12: + h=min(remaining,MYA4_ASSUMPTIONS['maximum_integration_step_s']) + for z in MYA4_ZONES: + if s[z+'.program.running'] and s[z+'.program.phase']=='holding': + needed=s[z+'.program.segments'][s[z+'.program.segment_index']]['hold_s']-s[z+'.program.hold_elapsed_s'] + if needed>1e-12:h=min(h,needed) + self._physics(s,h) + for z in MYA4_ZONES:self._program(s,z,h) + remaining-=h + for z in MYA4_ZONES: + s[z+'.stirring.angle_rad']=(s[z+'.stirring.angle_rad']+s[z+'.stirring.actual_rad_s']*dt_s)%(2*math.pi) + s[z+'.thermal.indicated_temperature_k']=round(s[z+'.thermal.temperature_k']-273.15,1)+273.15 + s[z+'.thermal.indicated_liquid_temperature_k']=round(s[z+'.thermal.liquid_temperature_k']-273.15,1)+273.15 + inst['revision']+=1 + self.time_s+=float(dt_s);self._publish_scene() + + +class RadleysMya4Session: + """Agent-facing fixed-identity interface; no role override or clock-control argument.""" + def __init__(self,host,principal_id):self.__host,self.__principal=host,principal_id + def _visible(self,info):return info['visibility']=='agent' or self.__host._principals[self.__principal][0] in ('debug','evaluator') + def _instance(self,sid): + if not isinstance(sid,str):return None + scope=self.__host._principals[self.__principal][1] + return self.__host._instances.get(sid) if scope is None or sid in scope else None + def _envelope(self,sid,request_id=None,*,result=None,observations=None,status='succeeded',error=None): + inst=self._instance(sid) + return {'protocol_version':PROTOCOL_VERSION,'instance_id':sid if isinstance(sid,str) else None,'request_id':request_id if isinstance(request_id,str) else None,'operation_id':None,'status':status, + 'state_revision':inst['revision'] if inst else None,'clock':{'domain':'simulation','time_s':self.__host.time_s},'result':copy.deepcopy(result or {}),'observations':copy.deepcopy(observations or {}),'error':error} + def _error(self,sid,code,request_id=None,status='rejected'): + messages={'UNKNOWN_INSTANCE':'Instance unavailable.','UNKNOWN_CAPABILITY':'Capability unavailable.','INVALID_ARGUMENT':'Arguments violate schema or bounds.','ACCESS_DENIED':'Request outside session policy.', + 'PRECONDITION_FAILED':'Required configuration or operating state unavailable.','BUSY':'Zone program is running.','REQUEST_CONFLICT':'Request ID already belongs to different arguments.','UNSUPPORTED':'Execution unavailable in this adapter.','DEVICE_ERROR':'Scene callback did not complete command.'} + return self._envelope(sid,request_id,status=status,error={'code':code,'message':messages[code],'retryable':False,'side_effects':'unknown' if code=='DEVICE_ERROR' else 'none','progress':None}) + def describe(self,*,asset_type_id=None,instance_id=None): + host=self.__host + with host._lock: + if (asset_type_id is None)==(instance_id is None):return self._error(None,'INVALID_ARGUMENT') + if instance_id is not None and not self._instance(instance_id):return self._error(instance_id,'UNKNOWN_INSTANCE') + if asset_type_id is not None and asset_type_id!=MYA4_TYPE:return self._error(None,'INVALID_ARGUMENT') + spec=copy.deepcopy(host._metadata['asset_types'][MYA4_TYPE]);spec['state_slots']={sid:info for sid,info in spec['state_slots'].items() if self._visible(info)} + spec['capabilities'].update(spec.pop('declared_capabilities')) + for cap in spec['capabilities'].values(): + cap['state_effects']=[e for e in cap['state_effects'] if e['state_id'] in spec['state_slots']];cap['observes']=[sid for sid in cap['observes'] if sid in spec['state_slots']] + return {'protocol_version':PROTOCOL_VERSION,'asset_type_id':MYA4_TYPE,'instance_id':instance_id,'adapter':'basic40_runtime_thermal.RadleysMya4Session',**spec,'limitations':copy.deepcopy(host._metadata['limitations'])} + def read(self,*,instance_id,state_ids=None): + host=self.__host + with host._lock: + inst=self._instance(instance_id) + if not inst:return self._error(instance_id,'UNKNOWN_INSTANCE') + slots=host._metadata['asset_types'][MYA4_TYPE]['state_slots'] + if state_ids is None:state_ids=[sid for sid,info in slots.items() if self._visible(info)] + if not isinstance(state_ids,list) or any(not isinstance(sid,str) for sid in state_ids) or len(set(state_ids))!=len(state_ids):return self._error(instance_id,'INVALID_ARGUMENT') + if any(sid not in slots or not self._visible(slots[sid]) for sid in state_ids):return self._error(instance_id,'ACCESS_DENIED') + obs={sid:{'value':copy.deepcopy(inst['state'][sid]),'unit':slots[sid]['unit'],'quality':'estimated' if slots[sid]['origin']=='derived' else 'valid','sample_time_s':host.time_s,'sample_window_s':None} for sid in state_ids} + return self._envelope(instance_id,observations=obs) + def invoke(self,*,instance_id,capability_id,arguments,request_id): + host=self.__host + with host._lock: + inst=self._instance(instance_id) + if not inst:return self._error(instance_id,'UNKNOWN_INSTANCE',request_id) + if not isinstance(capability_id,str) or not isinstance(arguments,dict) or not isinstance(request_id,str) or not request_id or len(request_id)>256:return self._error(instance_id,'INVALID_ARGUMENT',request_id) + try:digest=hashlib.sha256(json.dumps([capability_id,arguments],sort_keys=True,allow_nan=False).encode()).hexdigest() + except (TypeError,ValueError,OverflowError):return self._error(instance_id,'INVALID_ARGUMENT',request_id) + key=(self.__principal,instance_id,request_id) + if key in host._requests: + old,response=host._requests[key] + return copy.deepcopy(response) if old==digest else self._error(instance_id,'REQUEST_CONFLICT',request_id) + response=self._checked(instance_id,inst,capability_id,arguments,request_id) + host._requests[key]=(digest,copy.deepcopy(response));host._logs[self.__principal].append({'instance_id':instance_id,'capability_id':capability_id,'request_id':request_id,'response':copy.deepcopy(response)}) + return response + def _checked(self,sid,inst,cap,args,request_id): + host,old=self.__host,inst['state'];spec=host._metadata['asset_types'][MYA4_TYPE] + fail=lambda code,status='rejected':self._error(sid,code,request_id,status) + if cap in spec['declared_capabilities']:return fail('UNSUPPORTED','unsupported') + if cap not in spec['capabilities']:return fail('UNKNOWN_CAPABILITY') + schema=spec['capabilities'][cap]['input_schema']['properties'] + if set(args)!=set(schema):return fail('INVALID_ARGUMENT') + for name,info in schema.items(): + value=args[name] + if info['type']=='boolean' and type(value) is not bool:return fail('INVALID_ARGUMENT') + if info['type']=='integer' and (type(value) is not int or not info['minimum']<=value<=info['maximum']):return fail('INVALID_ARGUMENT') + if info['type']=='number' and (not _number(value) or not info.get('minimum',-math.inf)<=value<=info.get('maximum',math.inf)):return fail('INVALID_ARGUMENT') + if info['type']=='string' and value not in info['enum']:return fail('INVALID_ARGUMENT') + z=MYA4_ZONES[args['zone_index']] if 'zone_index' in args else None + if cap=='thermal.configure_program': + segs=args['segments'] + if not isinstance(segs,list) or not 1<=len(segs)<=16:return fail('INVALID_ARGUMENT') + for seg in segs: + if not isinstance(seg,dict) or set(seg)!={'temperature_K','hold_s'} or not _number(seg['temperature_K']) or not _number(seg['hold_s']) or not 243.15<=seg['temperature_K']<=453.15 or not 0<=seg['hold_s']<=86400:return fail('INVALID_ARGUMENT') + if z and old[z+'.program.running'] and cap not in ('thermal.stop_program','stirring.set_speed','stirring.set_enabled') and not (cap=='thermal.set_enabled' and not args['enabled']):return fail('BUSY') + needs_power=cap in ('thermal.set_temperature','thermal.set_probe_mode','thermal.configure_program','thermal.start_program','stirring.set_speed') or (cap in ('thermal.set_enabled','stirring.set_enabled') and args['enabled']) + if needs_power and not old['power.enabled']:return fail('PRECONDITION_FAILED') + if cap=='thermal.set_temperature' and not host._target_valid(old,z,args['temperature_K'],old[z+'.thermal.probe_mode']):return fail('PRECONDITION_FAILED') + if cap=='thermal.set_probe_mode' and not host._target_valid(old,z,old[z+'.thermal.target_k'],args['mode']):return fail('PRECONDITION_FAILED') + if cap=='thermal.configure_program' and any(not host._target_valid(old,z,seg['temperature_K'],old[z+'.thermal.probe_mode']) for seg in args['segments']):return fail('PRECONDITION_FAILED') + if cap in ('thermal.start_program','thermal.set_enabled') and (cap=='thermal.start_program' or args['enabled']): + if not old['cooling.available'] or not host._target_valid(old,z,old[z+'.thermal.target_k'],old[z+'.thermal.probe_mode']):return fail('PRECONDITION_FAILED') + if cap=='thermal.start_program': + if not old[z+'.program.segments'] or any(not host._target_valid(old,z,seg['temperature_K'],old[z+'.thermal.probe_mode']) for seg in old[z+'.program.segments']):return fail('PRECONDITION_FAILED') + if cap=='vessel.configure': + if args['fill_volume_m3']>args['capacity_m3']:return fail('INVALID_ARGUMENT') + if old[z+'.thermal.enabled'] or old[z+'.stirring.enabled'] or any(abs(old[z+'.thermal.'+suffix]-host.ambient_temperature_K)>1e-9 for suffix in ('temperature_k','liquid_temperature_k')):return fail('PRECONDITION_FAILED') + s=copy.deepcopy(old);result={'zone_index':args['zone_index']} if z else {} + if cap=='power.set': + s['power.enabled']=args['enabled'];result={'enabled':args['enabled']} + if not args['enabled']: + for name in MYA4_ZONES: + for f in ('thermal.enabled','stirring.enabled'):s[name+'.'+f]=False + s[name+'.stirring.actual_rad_s']=0.0 + if s[name+'.program.running']:s[name+'.program.running'],s[name+'.program.phase']=False,'interrupted_power' + elif cap=='thermal.set_temperature':s[z+'.thermal.target_k']=float(args['temperature_K']);result['setpoint_K']=float(args['temperature_K']) + elif cap=='thermal.set_probe_mode':s[z+'.thermal.probe_mode']=args['mode'];result['mode']=args['mode'] + elif cap=='thermal.set_enabled': + s[z+'.thermal.enabled']=args['enabled'];result['enabled']=args['enabled'] + if not args['enabled'] and s[z+'.program.running']:s[z+'.program.running'],s[z+'.program.phase']=False,'stopped' + elif cap=='stirring.set_speed': + s[z+'.stirring.target_rad_s']=float(args['angular_speed_rad_s']);result['angular_speed_rad_s']=float(args['angular_speed_rad_s']) + if s[z+'.stirring.enabled']:s[z+'.stirring.actual_rad_s']=s[z+'.stirring.target_rad_s'] + elif cap=='stirring.set_enabled': + s[z+'.stirring.enabled']=args['enabled'];s[z+'.stirring.actual_rad_s']=s[z+'.stirring.target_rad_s'] if args['enabled'] else 0.0;result['enabled']=args['enabled'] + elif cap=='vessel.configure': + for key in ('capacity_m3','fill_volume_m3'):s[z+'.vessel.'+key]=float(args[key]);result[key]=float(args[key]) + elif cap=='thermal.configure_program': + s[z+'.program.segments']=copy.deepcopy(args['segments']);s[z+'.program.phase']='idle' + for key in ('segment_index','hold_elapsed_s','reaction_elapsed_s'):s[z+'.program.'+key]=0 + result['segment_count']=len(args['segments']) + elif cap=='thermal.start_program': + s[z+'.program.running'],s[z+'.thermal.enabled'],s[z+'.program.phase']=True,True,'approaching' + for key in ('segment_index','hold_elapsed_s','reaction_elapsed_s'):s[z+'.program.'+key]=0 + s[z+'.thermal.target_k']=s[z+'.program.segments'][0]['temperature_K'];result['running']=True + elif cap=='thermal.stop_program':s[z+'.program.running'],s[z+'.thermal.enabled'],s[z+'.program.phase']=False,False,'stopped';result['running']=False + if s!=old: + if host.scene_adapter: + try:host.scene_adapter(sid,host._scene_payload(s)) + except Exception:return fail('DEVICE_ERROR','failed') + inst['state'],inst['revision']=s,inst['revision']+1 + return self._envelope(sid,request_id,result=result) + def write(self,*,instance_id,state_id,value,request_id): + host=self.__host + with host._lock: + if not self._instance(instance_id):return self._error(instance_id,'UNKNOWN_INSTANCE',request_id) + slots=host._metadata['asset_types'][MYA4_TYPE]['state_slots'];slot=slots.get(state_id) if isinstance(state_id,str) else None + if not slot or not self._visible(slot) or slot['access']!='read_write':return self._error(instance_id,'ACCESS_DENIED',request_id) + route=slot['write_via'] + return self.invoke(instance_id=instance_id,capability_id=route['capability_id'],arguments={**route.get('fixed_arguments',{}),route['parameter']:value},request_id=request_id) + def logs(self): + with self.__host._lock:return copy.deepcopy(self.__host._logs[self.__principal]) +# END CHEM-021 Radleys Mya 4 runtime. + + +def validate_radleys_mya4_runtime(output_directory=None): + """Execute only Mya4 tests; publish synthetic evidence without instance truth dumps.""" + import sys as _mya4_sys + import time as _mya4_time + root=Path(__file__).resolve().parents[1] + output=Path(output_directory) if output_directory else root/'outputs/basic40_batch02/t1_thermal/radleys_mya4' + for location in (root/'scripts',root/'tests',root/'skills/chemistry-lab-assets/scripts'): + if str(location) not in _mya4_sys.path:_mya4_sys.path.insert(0,str(location)) + import test_basic40_thermal as test_module + checks=[];stream=io.StringIO() + class Mya4EvidenceResult(unittest.TextTestResult): + def addSuccess(self,test): + checks.append({'check_id':test.id().split('.')[-1],'layer':'host' if any(tag in test.id() for tag in ('host_','agent_truth','request_replay','target_only','step_partition','scene_failure')) else 'process', + 'capability_ids':list(export_radleys_mya4_metadata()['asset_types'][MYA4_TYPE]['capabilities']),'status':'passed','method':'Executed unittest through real RadleysMya4Session entry points and trusted host; callbacks are recording stubs, not Blender geometry verification.'}) + super().addSuccess(test) + start=_mya4_time.monotonic() + suite=unittest.defaultTestLoader.loadTestsFromTestCase(test_module.RadleysMya4RuntimeTests) + result=unittest.TextTestRunner(stream=stream,verbosity=2,resultclass=Mya4EvidenceResult).run(suite) + report={'catalog_id':'CHEM-021','status':'passed' if result.wasSuccessful() else 'failed','checked_at':datetime.now(timezone.utc).isoformat(),'environment':{'python':platform.python_version(),'platform':platform.platform(),'bytecode_disabled':bool(_mya4_sys.dont_write_bytecode)}, + 'command':'PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=scripts:tests python3 -c "from basic40_runtime_thermal import validate_radleys_mya4_runtime; validate_radleys_mya4_runtime()"', + 'tests_run':result.testsRun,'failures':len(result.failures),'errors':len(result.errors),'elapsed_s':_mya4_time.monotonic()-start,'checks':checks, + 'not_run':['Blender geometry evaluation belongs to separate scene evidence','Real hardware','Real robot','Manufacturer dynamic calibration','Contact/collision solver','Chemical reaction kinetics'], + 'boundaries':export_radleys_mya4_metadata()['limitations']} + output.mkdir(parents=True,exist_ok=True) + (output/'runtime_verification.json').write_text(json.dumps(report,ensure_ascii=False,indent=2)+'\n') + (output/'runtime_tests.log').write_text(stream.getvalue()) + (output/'runtime_metadata.json').write_text(json.dumps(export_radleys_mya4_metadata(),ensure_ascii=False,indent=2)+'\n') + if not result.wasSuccessful():raise RuntimeError('Mya4 runtime verification failed; inspect runtime_tests.log') + return report