# 元件建模规范与示例

本文档是 `PythonModels/components` 下新增元件的最小开发规范。目标是让元件的端口、输入参数和可展示结果都由元件类显式声明，避免 XML 校验、求解器和前端分别维护同一份含义。

## 一、元件类必须声明的内容

每个元件类至少需要声明以下四个类属性：

```python
MODEL_TYPE = "example_component"
PORTS = (...)
PARAMETERS = (...)
RESULT_VARIABLES = (...)
```

- `MODEL_TYPE`：稳定的模型类型标识，对应 System XML 中的 `Component/@type`。发布后不要随意改名。
- `PORTS`：端口契约，包括端口名、物理域、变量和正流量方向。
- `PARAMETERS`：用户可配置的输入参数，包括默认值、物理量、SI 单位和取值范围。
- `RESULT_VARIABLES`：允许写入仿真结果并显示在结果页的组件级变量。端口结果由 `PORTS` 中的端口变量定义自动生成。

元件构造函数还必须：

1. 调用 `super().__init__(name)`。
2. 使用 `set_parameter_values()` 保存规范化后的输入参数。
3. 使用 `register_declared_port()` 创建已声明端口。
4. 若声明了组件结果变量，实现 `component_result_values()` 并返回对应数值；标准热力学容腔可以直接继承 `ThermodynamicVolumeComponent` 的实现。

## 二、输入参数与结果变量

输入参数和仿真结果必须分开声明：

- 输入参数描述一次仿真开始前由用户配置的量，例如 `volume`、`p0`、`T0`。
- 结果变量描述随时间变化、允许绘图的量，例如 `p`、`T`、`m`、`m_flow`。
- 求解器缓存、中间残差和调试字段不得自动暴露为结果变量。
- 参数名和结果变量名使用稳定的英文机器标识；`label` 专门用于界面显示。

参数定义示例：

```python
ParameterDefinition(
    name="volume",
    label="容积",
    quantity="volume",
    unit="m3",
    default=0.1,
    minimum=0.0,
    minimum_exclusive=True,
)
```

结果变量定义示例：

```python
ResultVariableDefinition(
    name="p",
    label="压力",
    quantity="pressure",
    unit="Pa",
    category="thermodynamic",
    order=30,
)
```

## 三、命名和单位约定

- 模型类型、参数、端口和变量名使用 `snake_case`，已有热力学惯例 `T`、`U` 可以保留。
- 输入参数保存和计算统一使用 SI 基准值；界面单位换算不能改变后端存储值。
- 无量纲参数的 `unit` 使用空字符串。
- `quantity` 表示稳定的物理量类型，例如 `pressure`、`temperature`、`mass_flow`，不能使用界面文案代替。
- 正质量流量统一定义为流入元件，即 `positiveFlowDirection="intoComponent"`。
- 端口变量 `p`、`m_flow`、`h_outflow` 的连接规则由 `PortDefinition.pneumatic()` 统一提供。

## 四、完整示例：单端口储气容腔

下面的示例展示一个可直接接入当前框架的动态元件。真实新增元件时应放入独立的 `.py` 文件，并补充对应测试。

```python
from __future__ import annotations

from collections.abc import Mapping

from PythonModels.core.base import ThermodynamicVolumeComponent
from PythonModels.core.equations import EquationResidual
from PythonModels.core.metadata import (
    ParameterDefinition,
    THERMODYNAMIC_VOLUME_RESULT_VARIABLES,
)
from PythonModels.core.medium import IdealGasMedium, ThermodynamicProperties
from PythonModels.core.ports import PortDefinition
from PythonModels.core.state import VolumeState


class ExampleVolume(ThermodynamicVolumeComponent):
    MODEL_TYPE = "example_volume"
    PORTS = (
        PortDefinition.pneumatic("port_a", nominal_role="bidirectional"),
    )
    PARAMETERS = (
        ParameterDefinition(
            name="volume",
            label="容积",
            quantity="volume",
            unit="m3",
            default=0.1,
            minimum=0.0,
            minimum_exclusive=True,
        ),
        ParameterDefinition(
            name="p0",
            label="初始压力",
            quantity="pressure",
            unit="Pa",
            default=100000.0,
            minimum=0.0,
            minimum_exclusive=True,
        ),
        ParameterDefinition(
            name="T0",
            label="初始温度",
            quantity="temperature",
            unit="K",
            default=300.0,
            minimum=0.0,
            minimum_exclusive=True,
        ),
    )
    RESULT_VARIABLES = THERMODYNAMIC_VOLUME_RESULT_VARIABLES

    def __init__(
        self,
        name: str,
        medium: IdealGasMedium,
        volume: float = 0.1,
        p0: float = 100000.0,
        T0: float = 300.0,
    ) -> None:
        super().__init__(name)
        self.set_parameter_values(
            {"volume": volume, "p0": p0, "T0": T0}
        )
        self.medium = medium
        self.V = volume
        initial_mass = p0 * volume / (medium.R_gas * T0)
        initial_energy = initial_mass * medium.specific_internal_energy(T0)
        self.state = VolumeState(m=initial_mass, U=initial_energy)
        self.port_a = self.register_declared_port("port_a")

    def get_state_vector(self) -> list[float]:
        return self.state.as_vector()

    def set_state_vector(self, values: list[float]) -> None:
        self.state = VolumeState.from_vector(values)

    def refresh_thermodynamic_ports(self) -> ThermodynamicProperties:
        properties = self.medium.properties_from_mU(
            self.state.m, self.state.U, self.V
        )
        self.port_a.p = properties.p
        self.port_a.h_outflow = properties.h
        return properties

    def state_derivative_from_ports(
        self,
        connected_h: Mapping[str, float],
    ) -> list[float]:
        properties = self.refresh_thermodynamic_ports()
        inlet_h = self.connection_inlet_enthalpy(
            port_m_flow=self.port_a.m_flow,
            connected_h=connected_h["port_a"],
            internal_h=properties.h,
        )
        return [self.port_a.m_flow, self.port_a.m_flow * inlet_h]

    def pressure_flow_equation_residuals(
        self,
    ) -> tuple[EquationResidual, ...]:
        pressure = self.medium.properties_from_mU(
            self.state.m, self.state.U, self.V
        ).p
        return (
            EquationResidual(
                id=f"{self.name}:port_a_pressure_state",
                owner="component",
                owner_id=self.name,
                relation="state",
                variables=(f"{self.name}.port_a.p", f"{self.name}.state"),
                role="effort",
                value=self.port_a.p - pressure,
            ),
        )
```

注册时只引用元件类已经声明的契约，不要再复制参数和端口定义：

```python
def _example_volume_factory(name, medium, values):
    return ExampleVolume(
        name=name,
        medium=medium,
        volume=values["volume"],
        p0=values["p0"],
        T0=values["T0"],
    )


COMPONENT_MODEL_REGISTRY[ExampleVolume.MODEL_TYPE] = ComponentModelSpec(
    model_type=ExampleVolume.MODEL_TYPE,
    ports=ExampleVolume.PORTS,
    parameters=ExampleVolume.PARAMETERS,
    factory=_example_volume_factory,
)
```

完成仿真后，每个已声明结果都会得到一条结构化元数据。前端应按字段筛选，不能再拆解 `key` 猜测含义：

```json
{
  "key": "example_volume_1.port_a.m_flow",
  "componentId": "example_volume_1",
  "componentType": "example_volume",
  "scope": "port",
  "portName": "port_a",
  "name": "m_flow",
  "label": "质量流量",
  "quantity": "mass_flow",
  "unit": "kg/s",
  "category": "flow",
  "order": 20
}
```

## 五、新增元件检查清单

1. `MODEL_TYPE` 是否唯一，并与 XML、前端组件类型一致。
2. 所有构造参数是否在 `PARAMETERS` 中声明并保存。
3. 所有端口是否在 `PORTS` 中声明并通过 `register_declared_port()` 创建。
4. `RESULT_VARIABLES` 与 `component_result_values()` 的键是否完全一致。
5. 结果变量是否包含明确的 `quantity`、`label`、`unit` 和显示顺序。
6. 是否只暴露有工程意义的结果，而非内部计算变量。
7. 是否补充参数边界、端口契约、结果元数据和最小仿真的自动测试。