Replace Python numerical kernels with native C execution

app/simulation/components/amesim/boundary/sources.py

@@ -1,14 +1,11 @@
+"""Component parameters, ports and output definitions; numerical equations execute in C."""
 from __future__ import annotations
-
 from collections.abc import Mapping
-
 from app.simulation.core.base import AlgebraicComponent
 from app.simulation.core.catalog import ComponentDisplaySpec, PortDisplaySpec
-from app.simulation.core.equations import EquationResidual
 from app.simulation.core.medium import IdealGasMedium
 from app.simulation.core.ports import PortDefinition
 
-
 class AmesimPnpl01(AlgebraicComponent):
     """AMESim PNPL01 zero pneumatic flow source.
 
@@ -16,53 +13,19 @@ class AmesimPnpl01(AlgebraicComponent):
     solver: it does not prescribe pressure, and only constrains its port mass
     flow to zero.
     """
-
-    MODEL_TYPE = "amesim_pnpl01"
-    MODEL_VERSION = "0.1.0"
-    PRESSURE_FLOW_DEPENDS_ON_STREAM = False
-    PORTS = (PortDefinition.pneumatic("port_1", nominal_role="bidirectional"),)
+    MODEL_TYPE = 'amesim_pnpl01'
+    MODEL_VERSION = '0.1.0'
+    PORTS = (PortDefinition.pneumatic('port_1', nominal_role='bidirectional'),)
     PARAMETERS = ()
     RESULT_VARIABLES = ()
-    DISPLAY = ComponentDisplaySpec(
-        label="PNPL01 零气动流边界",
-        library_id="amesim",
-        category_id="boundary",
-        symbol="amesim_pnpl01",
-        ports=(PortDisplaySpec("port_1", "left", order=10),),
-        order=10,
-    )
+    DISPLAY = ComponentDisplaySpec(label='PNPL01 零气动流边界', library_id='amesim', category_id='boundary', symbol='amesim_pnpl01', ports=(PortDisplaySpec('port_1', 'left', order=10),), order=10)
 
     def __init__(self, name: str) -> None:
         super().__init__(name=name)
         self.set_parameter_values({})
-        self.port_1 = self.register_declared_port("port_1")
+        self.port_1 = self.register_declared_port('port_1')
 
     @classmethod
-    def create(
-        cls,
-        *,
-        name: str,
-        medium: IdealGasMedium,
-        parameters: Mapping[str, float],
-    ) -> AmesimPnpl01:
+    def create(cls, *, name: str, medium: IdealGasMedium, parameters: Mapping[str, float]) -> AmesimPnpl01:
         return cls(name=name)
-
-    def pressure_flow_equation_values(self) -> tuple[float, ...]:
-        return (self.port_1.m_flow,)
-
-    def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
-        return (
-            EquationResidual(
-                id=f"{self.name}:zero_mass_flow",
-                owner="component",
-                owner_id=self.name,
-                relation="constitutive",
-                variables=(f"{self.name}.port_1.m_flow",),
-                role="flow",
-                value=self.port_1.m_flow,
-            ),
-        )
-
-    def update_stream_outflows(self, connected_h: Mapping[str, float]) -> None:
-        if "port_1" in connected_h:
-            self.port_1.h_outflow = connected_h["port_1"]
+    EQUATIONS = ({'id': '__MODEL__:zero_mass_flow', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'constitutive', 'variables': ['__MODEL__.port_1.m_flow'], 'role': 'flow'},)

app/simulation/components/amesim/junctions/nodes.py

@@ -1,31 +1,10 @@
+"""Component parameters, ports and output definitions; numerical equations execute in C."""
 from __future__ import annotations
-
 from collections.abc import Mapping
-
 from app.simulation.core.base import AlgebraicComponent
 from app.simulation.core.catalog import ComponentDisplaySpec, PortDisplaySpec
-from app.simulation.core.equations import EquationResidual
 from app.simulation.core.medium import IdealGasMedium
-from app.simulation.core.ports import PortDefinition, PortState
-
-
-_REFERENCE_OUTFLOW_REGULARIZATION_RATIO = 0.05
-
-
-def _regularized_inverse_outflow(flow: float, transition_flow: float) -> float:
-    """Return a C1 inverse that tends to zero as a negative flow vanishes."""
-
-    if flow >= 0.0:
-        return 0.0
-    transition_flow = max(float(transition_flow), 1.0e-12)
-    if -flow >= transition_flow:
-        return 1.0 / flow
-    return (
-        flow
-        * (2.0 * transition_flow * transition_flow - flow * flow)
-        / transition_flow**4
-    )
-
+from app.simulation.core.ports import PortDefinition
 
 class _AmesimPneumaticNode(AlgebraicComponent):
     """Shared implementation for AMESim pneumatic junction submodels.
@@ -35,9 +14,7 @@ class _AmesimPneumaticNode(AlgebraicComponent):
     an outlet, its enthalpy is the residual that closes the junction energy
     balance, matching the AMESim dh2 causality.
     """
-
-    PRESSURE_FLOW_DEPENDS_ON_STREAM = False
-    REFERENCE_PORT = "port_2"
+    REFERENCE_PORT = 'port_2'
 
     def __init__(self, name: str) -> None:
         super().__init__(name=name)
@@ -46,194 +23,30 @@ class _AmesimPneumaticNode(AlgebraicComponent):
         for definition in self.PORTS:
             setattr(self, definition.name, self.register_declared_port(definition.name))
 
-    def pressure_flow_equation_values(self) -> tuple[float, ...]:
-        reference = self.get_port(self.REFERENCE_PORT)
-        return tuple(
-            self.get_port(definition.name).p - reference.p
-            for definition in self.PORTS
-            if definition.name != self.REFERENCE_PORT
-        ) + (
-            sum(
-                self.get_port(definition.name).m_flow
-                for definition in self.PORTS
-            ),
-        )
-
-    def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
-        reference = self.get_port(self.REFERENCE_PORT)
-        residuals: list[EquationResidual] = []
-        for definition in self.PORTS:
-            if definition.name == self.REFERENCE_PORT:
-                continue
-            port = self.get_port(definition.name)
-            residuals.append(
-                EquationResidual(
-                    id=f"{self.name}:{definition.name}_pressure_reference",
-                    owner="component",
-                    owner_id=self.name,
-                    relation="equal",
-                    variables=(
-                        f"{self.name}.{definition.name}.p",
-                        f"{self.name}.{self.REFERENCE_PORT}.p",
-                    ),
-                    role="effort",
-                    value=port.p - reference.p,
-                )
-            )
-        residuals.append(
-            EquationResidual(
-                id=f"{self.name}:mass_flow_balance",
-                owner="component",
-                owner_id=self.name,
-                relation="sumToZero",
-                variables=tuple(
-                    f"{self.name}.{definition.name}.m_flow"
-                    for definition in self.PORTS
-                ),
-                role="flow",
-                value=sum(self.get_port(definition.name).m_flow for definition in self.PORTS),
-            )
-        )
-        return tuple(residuals)
-
-    def update_stream_outflows(self, connected_h: Mapping[str, float]) -> None:
-        self.temperature_reference_h = connected_h.get(
-            self.REFERENCE_PORT,
-            sum(connected_h.values()) / len(connected_h) if connected_h else 0.0,
-        )
-        incoming = [
-            (port.m_flow, connected_h[name])
-            for name, port in self.ports.items()
-            if port.m_flow > 1e-12
-        ]
-        total_flow = sum(m_flow for m_flow, _ in incoming)
-        if total_flow > 1e-12:
-            mixed_h = sum(m_flow * h for m_flow, h in incoming) / total_flow
-        else:
-            mixed_h = self.temperature_reference_h
-
-        reference_port = self.get_port(self.REFERENCE_PORT)
-        for name, port in self.ports.items():
-            port.h_outflow = (
-                mixed_h
-                if name == self.REFERENCE_PORT
-                else self.temperature_reference_h
-            )
-
-        if reference_port.m_flow < 0.0:
-            energy_without_reference = sum(
-                port.m_flow
-                * (
-                    connected_h[name]
-                    if port.m_flow > 1e-12
-                    else self.temperature_reference_h
-                )
-                for name, port in self.ports.items()
-                if name != self.REFERENCE_PORT
-            )
-            non_reference_flow_scale = sum(
-                abs(port.m_flow)
-                for name, port in self.ports.items()
-                if name != self.REFERENCE_PORT
-            )
-            transition_flow = (
-                _REFERENCE_OUTFLOW_REGULARIZATION_RATIO
-                * non_reference_flow_scale
-            )
-            # Port 2 carries AMESim's residual-energy causality.  Exact
-            # division is singular when its outflow reverses through zero, so
-            # use a C1 band that matches the exact balance at its boundary and
-            # tends to the mixed enthalpy at zero flow.
-            inverse_flow = _regularized_inverse_outflow(
-                reference_port.m_flow,
-                transition_flow,
-            )
-            energy_residual_at_mixed_h = (
-                energy_without_reference
-                + reference_port.m_flow * mixed_h
-            )
-            reference_port.h_outflow = (
-                mixed_h - energy_residual_at_mixed_h * inverse_flow
-            )
-
-
 class AmesimPn3Node2(_AmesimPneumaticNode):
     """AMESim PN3NODE2 pneumatic three-port junction."""
-
-    MODEL_TYPE = "amesim_pn3node2"
-    MODEL_VERSION = "0.3.0"
-    PRESSURE_FLOW_DEPENDS_ON_STREAM = False
-    PRESSURE_FLOW_EXACT_SUM_TO_ZERO_EQUATION_SUFFIXES = frozenset(
-        ("mass_flow_balance",)
-    )
-    PORTS = (
-        PortDefinition.pneumatic("port_1", nominal_role="bidirectional"),
-        PortDefinition.pneumatic("port_2", nominal_role="bidirectional"),
-        PortDefinition.pneumatic("port_3", nominal_role="bidirectional"),
-    )
+    MODEL_TYPE = 'amesim_pn3node2'
+    MODEL_VERSION = '0.3.0'
+    PORTS = (PortDefinition.pneumatic('port_1', nominal_role='bidirectional'), PortDefinition.pneumatic('port_2', nominal_role='bidirectional'), PortDefinition.pneumatic('port_3', nominal_role='bidirectional'))
     PARAMETERS = ()
     RESULT_VARIABLES = ()
-    DISPLAY = ComponentDisplaySpec(
-        label="PN3NODE2 三端气动节点",
-        library_id="amesim",
-        category_id="junctions",
-        symbol="amesim_pn3node2",
-        ports=(
-            PortDisplaySpec("port_1", "left", order=10),
-            PortDisplaySpec("port_2", "right", order=20),
-            PortDisplaySpec("port_3", "right", order=30),
-        ),
-        order=10,
-    )
+    DISPLAY = ComponentDisplaySpec(label='PN3NODE2 三端气动节点', library_id='amesim', category_id='junctions', symbol='amesim_pn3node2', ports=(PortDisplaySpec('port_1', 'left', order=10), PortDisplaySpec('port_2', 'right', order=20), PortDisplaySpec('port_3', 'right', order=30)), order=10)
 
     @classmethod
-    def create(
-        cls,
-        *,
-        name: str,
-        medium: IdealGasMedium,
-        parameters: Mapping[str, float],
-    ) -> AmesimPn3Node2:
+    def create(cls, *, name: str, medium: IdealGasMedium, parameters: Mapping[str, float]) -> AmesimPn3Node2:
         return cls(name=name)
-
+    EQUATIONS = ({'id': '__MODEL__:port_1_pressure_reference', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'equal', 'variables': ['__MODEL__.port_1.p', '__MODEL__.port_2.p'], 'role': 'effort'}, {'id': '__MODEL__:port_3_pressure_reference', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'equal', 'variables': ['__MODEL__.port_3.p', '__MODEL__.port_2.p'], 'role': 'effort'}, {'id': '__MODEL__:mass_flow_balance', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'sumToZero', 'variables': ['__MODEL__.port_1.m_flow', '__MODEL__.port_2.m_flow', '__MODEL__.port_3.m_flow'], 'role': 'flow'})
 
 class AmesimP4Node2(_AmesimPneumaticNode):
     """AMESim P4NODE2 pneumatic four-port junction."""
-
-    MODEL_TYPE = "amesim_p4node2"
-    MODEL_VERSION = "0.3.0"
-    PRESSURE_FLOW_DEPENDS_ON_STREAM = False
-    PRESSURE_FLOW_EXACT_SUM_TO_ZERO_EQUATION_SUFFIXES = frozenset(
-        ("mass_flow_balance",)
-    )
-    PORTS = (
-        PortDefinition.pneumatic("port_1", nominal_role="bidirectional"),
-        PortDefinition.pneumatic("port_2", nominal_role="bidirectional"),
-        PortDefinition.pneumatic("port_3", nominal_role="bidirectional"),
-        PortDefinition.pneumatic("port_4", nominal_role="bidirectional"),
-    )
+    MODEL_TYPE = 'amesim_p4node2'
+    MODEL_VERSION = '0.3.0'
+    PORTS = (PortDefinition.pneumatic('port_1', nominal_role='bidirectional'), PortDefinition.pneumatic('port_2', nominal_role='bidirectional'), PortDefinition.pneumatic('port_3', nominal_role='bidirectional'), PortDefinition.pneumatic('port_4', nominal_role='bidirectional'))
     PARAMETERS = ()
     RESULT_VARIABLES = ()
-    DISPLAY = ComponentDisplaySpec(
-        label="P4NODE2 四端气动节点",
-        library_id="amesim",
-        category_id="junctions",
-        symbol="amesim_p4node2",
-        ports=(
-            PortDisplaySpec("port_1", "left", order=10),
-            PortDisplaySpec("port_2", "right", order=20),
-            PortDisplaySpec("port_3", "right", order=30),
-            PortDisplaySpec("port_4", "right", order=40),
-        ),
-        order=20,
-    )
+    DISPLAY = ComponentDisplaySpec(label='P4NODE2 四端气动节点', library_id='amesim', category_id='junctions', symbol='amesim_p4node2', ports=(PortDisplaySpec('port_1', 'left', order=10), PortDisplaySpec('port_2', 'right', order=20), PortDisplaySpec('port_3', 'right', order=30), PortDisplaySpec('port_4', 'right', order=40)), order=20)
 
     @classmethod
-    def create(
-        cls,
-        *,
-        name: str,
-        medium: IdealGasMedium,
-        parameters: Mapping[str, float],
-    ) -> AmesimP4Node2:
+    def create(cls, *, name: str, medium: IdealGasMedium, parameters: Mapping[str, float]) -> AmesimP4Node2:
         return cls(name=name)
+    EQUATIONS = ({'id': '__MODEL__:port_1_pressure_reference', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'equal', 'variables': ['__MODEL__.port_1.p', '__MODEL__.port_2.p'], 'role': 'effort'}, {'id': '__MODEL__:port_3_pressure_reference', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'equal', 'variables': ['__MODEL__.port_3.p', '__MODEL__.port_2.p'], 'role': 'effort'}, {'id': '__MODEL__:port_4_pressure_reference', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'equal', 'variables': ['__MODEL__.port_4.p', '__MODEL__.port_2.p'], 'role': 'effort'}, {'id': '__MODEL__:mass_flow_balance', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'sumToZero', 'variables': ['__MODEL__.port_1.m_flow', '__MODEL__.port_2.m_flow', '__MODEL__.port_3.m_flow', '__MODEL__.port_4.m_flow'], 'role': 'flow'})

app/simulation/components/amesim/mechanical/pistons.py

@@ -1,36 +1,15 @@
+"""Component parameters, ports and output definitions; numerical equations execute in C."""
 from __future__ import annotations
-
-from collections.abc import Mapping, Sequence
-from dataclasses import dataclass
-from math import isfinite, pi
-
-from app.simulation.components.amesim.gases import (
-    AMESIM_GAS_INDEX_PARAMETER,
-    normalize_amesim_gas_index,
-)
+from collections.abc import Mapping
+from math import pi
+from app.simulation.components.amesim.gases import AMESIM_GAS_INDEX_PARAMETER, normalize_amesim_gas_index
 from app.simulation.core.base import AlgebraicComponent
 from app.simulation.core.catalog import ComponentDisplaySpec, PortDisplaySpec
-from app.simulation.core.equations import EquationResidual
 from app.simulation.core.metadata import ParameterDefinition, ResultVariableDefinition
 from app.simulation.core.medium import GasMedium
 from app.simulation.core.ports import PortDefinition
-
-
 AMESIM_REFERENCE_PRESSURE_PA = 101300.0
 
-
-@dataclass(frozen=True)
-class Pnrp17Linearization:
-    volume: float
-    volume_flow: float
-    pressure_force: float
-    volume_tangent: tuple[float, ...]
-    volume_flow_tangent: tuple[float, ...]
-    pressure_force_tangent: tuple[float, ...]
-    valid: bool = True
-    reason: str | None = None
-
-
 class AmesimPnrp17(AlgebraicComponent):
     """AMESim PNRP17 pneumatic piston with two mechanical faces.
 
@@ -38,268 +17,32 @@ class AmesimPnrp17(AlgebraicComponent):
     cylinder-side motion. The pneumatic port contributes its swept volume and
     volume rate to the connected variable-volume chamber.
     """
+    MODEL_TYPE = 'amesim_pnrp17'
+    MODEL_VERSION = '0.1.0'
+    PORTS = (PortDefinition.pneumatic('port_1', nominal_role='bidirectional'), PortDefinition.mechanical_translational('port_2'), PortDefinition.mechanical_translational('port_3'), PortDefinition.mechanical_translational('port_4'), PortDefinition.mechanical_translational('port_5'))
+    PARAMETERS = (AMESIM_GAS_INDEX_PARAMETER, ParameterDefinition('dp', 0.2, label='活塞直径', quantity='length', unit='m', minimum=0.0, minimum_exclusive=True, description='活塞外径；与活塞杆直径共同确定有效受压面积。'), ParameterDefinition('dr', 0.001, label='活塞杆直径', quantity='length', unit='m', minimum=0.0, description='穿过气室一侧的活塞杆直径，必须不大于活塞直径。'), ParameterDefinition('x0', 0.0, label='初始腔长', quantity='length', unit='m', description='机械端位移均为零时的气动腔长度。'))
+    RESULT_VARIABLES = (ResultVariableDefinition('volume', '扫掠容积', 'volume', 'm3', 'derived', 10), ResultVariableDefinition('volume_flow', '扫掠容积变化率', 'volume_flow', 'm3/s', 'derived', 20), ResultVariableDefinition('length', '气动腔长度', 'length', 'm', 'derived', 30), ResultVariableDefinition('pressure_force', '气压力', 'force', 'N', 'derived', 40))
+    DISPLAY = ComponentDisplaySpec(label='PNRP17 气动活塞', library_id='amesim', category_id='mechanical', symbol='amesim_pnrp17', ports=(PortDisplaySpec('port_1', 'left', order=10), PortDisplaySpec('port_3', 'left', order=20), PortDisplaySpec('port_2', 'left', order=30), PortDisplaySpec('port_4', 'right', order=40), PortDisplaySpec('port_5', 'right', order=50)), order=60)
 
-    MODEL_TYPE = "amesim_pnrp17"
-    MODEL_VERSION = "0.1.0"
-    PRESSURE_FLOW_DEPENDS_ON_STREAM = False
-    PORTS = (
-        PortDefinition.pneumatic("port_1", nominal_role="bidirectional"),
-        PortDefinition.mechanical_translational("port_2"),
-        PortDefinition.mechanical_translational("port_3"),
-        PortDefinition.mechanical_translational("port_4"),
-        PortDefinition.mechanical_translational("port_5"),
-    )
-    PARAMETERS = (
-        AMESIM_GAS_INDEX_PARAMETER,
-        ParameterDefinition(
-            "dp",
-            0.2,
-            label="活塞直径",
-            quantity="length",
-            unit="m",
-            minimum=0.0,
-            minimum_exclusive=True,
-            description="活塞外径；与活塞杆直径共同确定有效受压面积。",
-        ),
-        ParameterDefinition(
-            "dr",
-            0.001,
-            label="活塞杆直径",
-            quantity="length",
-            unit="m",
-            minimum=0.0,
-            description="穿过气室一侧的活塞杆直径，必须不大于活塞直径。",
-        ),
-        ParameterDefinition(
-            "x0",
-            0.0,
-            label="初始腔长",
-            quantity="length",
-            unit="m",
-            description="机械端位移均为零时的气动腔长度。",
-        ),
-    )
-    RESULT_VARIABLES = (
-        ResultVariableDefinition("volume", "扫掠容积", "volume", "m3", "derived", 10),
-        ResultVariableDefinition(
-            "volume_flow",
-            "扫掠容积变化率",
-            "volume_flow",
-            "m3/s",
-            "derived",
-            20,
-        ),
-        ResultVariableDefinition("length", "气动腔长度", "length", "m", "derived", 30),
-        ResultVariableDefinition(
-            "pressure_force",
-            "气压力",
-            "force",
-            "N",
-            "derived",
-            40,
-        ),
-    )
-    DISPLAY = ComponentDisplaySpec(
-        label="PNRP17 气动活塞",
-        library_id="amesim",
-        category_id="mechanical",
-        symbol="amesim_pnrp17",
-        ports=(
-            PortDisplaySpec("port_1", "left", order=10),
-            PortDisplaySpec("port_3", "left", order=20),
-            PortDisplaySpec("port_2", "left", order=30),
-            PortDisplaySpec("port_4", "right", order=40),
-            PortDisplaySpec("port_5", "right", order=50),
-        ),
-        order=60,
-    )
-
-    def __init__(
-        self,
-        name: str,
-        medium: GasMedium,
-        *,
-        gi: float = 0.0,
-        dp: float = 0.2,
-        dr: float = 0.001,
-        x0: float = 0.0,
-    ) -> None:
+    def __init__(self, name: str, medium: GasMedium, *, gi: float=0.0, dp: float=0.2, dr: float=0.001, x0: float=0.0) -> None:
         super().__init__(name=name)
-        self.set_parameter_values({"gi": gi, "dp": dp, "dr": dr, "x0": x0})
+        self.set_parameter_values({'gi': gi, 'dp': dp, 'dr': dr, 'x0': x0})
         self.medium = medium
         self.gi = normalize_amesim_gas_index(gi)
         self.dp = float(dp)
         self.dr = float(dr)
         self.x0 = float(x0)
         if self.dr > self.dp:
-            raise ValueError("PNRP17 rod diameter dr must not exceed piston diameter dp.")
+            raise ValueError('PNRP17 rod diameter dr must not exceed piston diameter dp.')
         for definition in self.PORTS:
             port = self.register_declared_port(definition.name)
             setattr(self, definition.name, port)
-        self.port_1.h_outflow = medium.specific_enthalpy(medium.T_ref)
 
     @classmethod
-    def create(
-        cls,
-        *,
-        name: str,
-        medium: GasMedium,
-        parameters: Mapping[str, float],
-    ) -> "AmesimPnrp17":
+    def create(cls, *, name: str, medium: GasMedium, parameters: Mapping[str, float]) -> 'AmesimPnrp17':
         return cls(name=name, medium=medium, **dict(parameters))
 
     @property
     def effective_area(self) -> float:
         return pi * (self.dp * self.dp - self.dr * self.dr) / 4.0
-
-    @property
-    def chamber_length(self) -> float:
-        return self.x0 + self.port_5.x - self.port_4.x
-
-    @property
-    def chamber_volume(self) -> float:
-        return self.effective_area * self.chamber_length
-
-    @property
-    def chamber_volume_flow(self) -> float:
-        return self.effective_area * (self.port_5.v - self.port_4.v)
-
-    @property
-    def pressure_force(self) -> float:
-        return (self.port_1.p - AMESIM_REFERENCE_PRESSURE_PA) * self.effective_area
-
-    def pressure_flow_equation_values(self) -> tuple[float, ...]:
-        values = [self.port_1.m_flow]
-        effort_pairs = (("port_2", "port_5"), ("port_3", "port_4"))
-        for first_name, second_name in effort_pairs:
-            first = self.get_port(first_name)
-            second = self.get_port(second_name)
-            values.extend((first.x - second.x, first.v - second.v))
-        force = self.pressure_force
-        values.extend(
-            (
-                self.port_2.f + self.port_5.f + force,
-                self.port_3.f + self.port_4.f - force,
-            )
-        )
-        return tuple(values)
-
-    def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
-        effort_pairs = (("port_2", "port_5"), ("port_3", "port_4"))
-        residuals: list[EquationResidual] = [
-            EquationResidual(
-                id=f"{self.name}:pneumatic_zero_mass_flow",
-                owner="component",
-                owner_id=self.name,
-                relation="constitutive",
-                variables=(f"{self.name}.port_1.m_flow",),
-                role="flow",
-                value=self.port_1.m_flow,
-            )
-        ]
-        for first_name, second_name in effort_pairs:
-            first = self.get_port(first_name)
-            second = self.get_port(second_name)
-            for variable in ("x", "v"):
-                residuals.append(
-                    EquationResidual(
-                        id=f"{self.name}:{first_name}_{second_name}_{variable}_equal",
-                        owner="component",
-                        owner_id=self.name,
-                        relation="equal",
-                        variables=(
-                            f"{self.name}.{first_name}.{variable}",
-                            f"{self.name}.{second_name}.{variable}",
-                        ),
-                        role="effort",
-                        value=getattr(first, variable) - getattr(second, variable),
-                    )
-                )
-        force = self.pressure_force
-        residuals.extend(
-            (
-                EquationResidual(
-                    id=f"{self.name}:piston_side_force_balance",
-                    owner="component",
-                    owner_id=self.name,
-                    relation="constitutive",
-                    variables=(f"{self.name}.port_2.f", f"{self.name}.port_5.f", f"{self.name}.port_1.p"),
-                    role="flow",
-                    value=self.port_2.f + self.port_5.f + force,
-                ),
-                EquationResidual(
-                    id=f"{self.name}:cylinder_side_force_balance",
-                    owner="component",
-                    owner_id=self.name,
-                    relation="constitutive",
-                    variables=(f"{self.name}.port_3.f", f"{self.name}.port_4.f", f"{self.name}.port_1.p"),
-                    role="flow",
-                    value=self.port_3.f + self.port_4.f - force,
-                ),
-            )
-        )
-        return tuple(residuals)
-
-    def pneumatic_volume_outputs(self) -> Mapping[str, tuple[float, float]]:
-        return {"port_1": (self.chamber_volume, self.chamber_volume_flow)}
-
-    def linearize_geometry_and_force(
-        self,
-        port_4_x_tangent: Sequence[float],
-        port_5_x_tangent: Sequence[float],
-        port_4_v_tangent: Sequence[float],
-        port_5_v_tangent: Sequence[float],
-        port_1_pressure_tangent: Sequence[float],
-    ) -> Pnrp17Linearization:
-        """Return exact piston geometry and pressure-force tangents."""
-
-        vectors = tuple(
-            tuple(float(value) for value in values)
-            for values in (
-                port_4_x_tangent,
-                port_5_x_tangent,
-                port_4_v_tangent,
-                port_5_v_tangent,
-                port_1_pressure_tangent,
-            )
-        )
-        widths = {len(values) for values in vectors}
-        if len(widths) != 1:
-            raise ValueError("PNRP17 tangent vectors must have equal lengths.")
-        valid = all(isfinite(value) for values in vectors for value in values)
-        area = self.effective_area
-        volume_tangent = tuple(
-            area * (right - left)
-            for left, right in zip(vectors[0], vectors[1], strict=True)
-        )
-        volume_flow_tangent = tuple(
-            area * (right - left)
-            for left, right in zip(vectors[2], vectors[3], strict=True)
-        )
-        pressure_force_tangent = tuple(
-            area * value for value in vectors[4]
-        )
-        return Pnrp17Linearization(
-            volume=self.chamber_volume,
-            volume_flow=self.chamber_volume_flow,
-            pressure_force=self.pressure_force,
-            volume_tangent=volume_tangent,
-            volume_flow_tangent=volume_flow_tangent,
-            pressure_force_tangent=pressure_force_tangent,
-            valid=valid,
-            reason=None if valid else "non_finite_tangent_input",
-        )
-
-    def update_stream_outflows(self, connected_h: Mapping[str, float]) -> None:
-        self.port_1.h_outflow = connected_h.get(
-            "port_1",
-            self.medium.specific_enthalpy(self.medium.T_ref),
-        )
-
-    def component_result_values(self) -> Mapping[str, float]:
-        return {
-            "volume": self.chamber_volume,
-            "volume_flow": self.chamber_volume_flow,
-            "length": self.chamber_length,
-            "pressure_force": self.pressure_force,
-        }
+    EQUATIONS = ({'id': '__MODEL__:pneumatic_zero_mass_flow', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'constitutive', 'variables': ['__MODEL__.port_1.m_flow'], 'role': 'flow'}, {'id': '__MODEL__:port_2_port_5_x_equal', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'equal', 'variables': ['__MODEL__.port_2.x', '__MODEL__.port_5.x'], 'role': 'effort'}, {'id': '__MODEL__:port_2_port_5_v_equal', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'equal', 'variables': ['__MODEL__.port_2.v', '__MODEL__.port_5.v'], 'role': 'effort'}, {'id': '__MODEL__:port_3_port_4_x_equal', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'equal', 'variables': ['__MODEL__.port_3.x', '__MODEL__.port_4.x'], 'role': 'effort'}, {'id': '__MODEL__:port_3_port_4_v_equal', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'equal', 'variables': ['__MODEL__.port_3.v', '__MODEL__.port_4.v'], 'role': 'effort'}, {'id': '__MODEL__:piston_side_force_balance', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'constitutive', 'variables': ['__MODEL__.port_2.f', '__MODEL__.port_5.f', '__MODEL__.port_1.p'], 'role': 'flow'}, {'id': '__MODEL__:cylinder_side_force_balance', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'constitutive', 'variables': ['__MODEL__.port_3.f', '__MODEL__.port_4.f', '__MODEL__.port_1.p'], 'role': 'flow'})

app/simulation/components/amesim/media/mediums.py

@@ -1,488 +1,42 @@
+"""Gas identities and constants passed to the native compiler."""
 from __future__ import annotations
-
-from collections.abc import Callable, Sequence
+from collections.abc import Callable
 from dataclasses import dataclass
-from math import exp, isfinite, log
 from typing import ClassVar
-
-from app.simulation.core.errors import RecoverableTrialStateError
-from app.simulation.core.medium import (
-    GasMedium,
-    IdealGasMedium,
-    ThermodynamicProperties,
-    ThermodynamicPropertiesLinearization,
-    ThermodynamicPropertyTangents,
-)
-from app.simulation.core.peng_robinson import HELIUM_PR, PengRobinsonFluid
-from app.simulation.performance import profile_property, record_property_iterations
-from app.simulation.property_cache import cache_property_calculation
-
+from app.simulation.core.medium import GasMedium, IdealGasMedium
 
 @dataclass(frozen=True)
 class AmesimIdealAirMedium(IdealGasMedium):
-    """AMESim air properties evaluated with the ideal-gas method.
-
-    Substance identity and property method are part of the concrete Python
-    type.  A future air correlation or helium Peng-Robinson implementation can
-    therefore coexist as a sibling type without turning ``gi`` into a fluid
-    enumeration.
-    """
-
-    SUBSTANCE_ID: ClassVar[str] = "air"
-    PROPERTY_METHOD_ID: ClassVar[str] = "ideal_gas"
-
-    name: str = "AMESimAirIdealGas"
+    SUBSTANCE_ID: ClassVar[str] = 'air'
+    PROPERTY_METHOD_ID: ClassVar[str] = 'ideal_gas'
+    name: str = 'AMESimAirIdealGas'
     R_gas: float = 287.0
     cp_ref: float = 1005.0
     T_ref: float = 300.0
     cp_slope: float = 0.0
-    viscosity_ref: float = 1.82e-5
+    viscosity_ref: float = 1.82e-05
     viscosity_T_ref: float = 293.15
     sutherland_constant: float = 110.4
 
-
 @dataclass(frozen=True)
 class AmesimHeliumPengRobinsonMedium(IdealGasMedium):
-    """AMESim helium with a Peng-Robinson mechanical equation of state.
-
-    The pressure-density-temperature relation is evaluated by the shared
-    ``HELIUM_PR`` fluid.  The caloric reference follows the constant NASA
-    polynomial from Simcenter Amesim 2404 ``helium_cp_h_s.data``.
-    """
-
-    SUBSTANCE_ID: ClassVar[str] = "helium"
-    PROPERTY_METHOD_ID: ClassVar[str] = "peng_robinson"
-    fluid: ClassVar[PengRobinsonFluid] = HELIUM_PR
+    SUBSTANCE_ID: ClassVar[str] = 'helium'
+    PROPERTY_METHOD_ID: ClassVar[str] = 'peng_robinson'
     nasa_cp_over_R: ClassVar[float] = 2.5
     nasa_enthalpy_constant_K: ClassVar[float] = -745.375
-    nasa_viscosity_coefficients: ClassVar[tuple[float, float, float, float]] = (
-        0.7501594,
-        35.76324,
-        -2212.129,
-        0.9212635,
-    )
-
-    name: str = "AMESimHeliumPengRobinson"
-    R_gas: float = HELIUM_PR.specific_gas_constant
-    cp_ref: float = nasa_cp_over_R * HELIUM_PR.specific_gas_constant
+    nasa_viscosity_coefficients: ClassVar[tuple[float, float, float, float]] = (0.7501594, 35.76324, -2212.129, 0.9212635)
+    name: str = 'AMESimHeliumPengRobinson'
+    R_gas: float = 8.31446261815324 / 0.004002602
+    cp_ref: float = 2.5 * (8.31446261815324 / 0.004002602)
     T_ref: float = 293.15
     cp_slope: float = 0.0
-    viscosity_ref: float = 1.96e-5
+    viscosity_ref: float = 1.96e-05
     viscosity_T_ref: float = 293.15
     sutherland_constant: float = 79.4
 
-    @property
-    def cv(self) -> float:
-        return (self.nasa_cp_over_R - 1.0) * self.R_gas
-
-    def cv_at_temperature(self, T: float) -> float:
-        del T
-        return self.cv
-
-    def diagnostic_dynamic_viscosity(self, T: float) -> float:
-        """Return the AMESim NASA-table viscosity used by pipe diagnostics.
-
-        pn2pipefr reports Reynolds number with sagum viscosity. Keep this
-        separate from dynamic_viscosity so matching that diagnostic cannot
-        alter the already-validated pipe flow or friction dynamics.
-        """
-
-        if T <= 0.0:
-            raise ValueError("Temperature must be positive.")
-        a, b, c, d = self.nasa_viscosity_coefficients
-        return 1.0e-7 * exp(a * log(T) + b / T + c / (T * T) + d)
-
-    @profile_property("density")
-    @cache_property_calculation("density")
-    def density(self, p: float, T: float) -> float:
-        return self.fluid.density(p, T)
-
-    def _real_heat_capacities(
-        self,
-        p: float,
-        T: float,
-    ) -> tuple[float, float, float, float, float]:
-        density = self.density(p, T)
-        pressure_density_derivative = (
-            self.fluid.pressure_density_derivative_at_temperature(
-                T,
-                density,
-            )
-        )
-        pressure_temperature_derivative = (
-            self.fluid.pressure_temperature_derivative_at_density(
-                T,
-                density,
-            )
-        )
-        cv = (
-            self.cv_at_temperature(T)
-            + self.fluid.residual_isochoric_heat_capacity_at_density(T, density)
-        )
-        cp = (
-            cv
-            + T
-            * pressure_temperature_derivative
-            * pressure_temperature_derivative
-            / (density * density * pressure_density_derivative)
-        )
-        if cp <= 0.0 or cv <= 0.0:
-            raise ValueError("Real-gas heat capacities must be positive.")
-        return (
-            cp,
-            cv,
-            density,
-            pressure_density_derivative,
-            pressure_temperature_derivative,
-        )
-
-    def _local_isentropic_density_pressure_factor(
-        self,
-        p: float,
-        T: float,
-    ) -> tuple[float, float]:
-        cp, cv, density, pressure_density_derivative, pressure_temperature_derivative = (
-            self._real_heat_capacities(p, T)
-        )
-        heat_capacity_ratio = cp / cv
-        factor = p / (
-            density * pressure_density_derivative * heat_capacity_ratio
-        )
-        exponent = (
-            p
-            * (heat_capacity_ratio - 1.0)
-            / (
-                heat_capacity_ratio
-                * T
-                * pressure_temperature_derivative
-            )
-        )
-        return factor, exponent
-
-    @profile_property("isentropic_density_pressure_factor")
-    @cache_property_calculation("isentropic_density_pressure_factor")
-    def isentropic_density_pressure_factor(
-        self,
-        p: float,
-        T: float,
-        downstream_pressure: float | None = None,
-    ) -> float:
-        upstream_factor, isentropic_temperature_exponent = (
-            self._local_isentropic_density_pressure_factor(p, T)
-        )
-        if downstream_pressure is None or downstream_pressure >= p:
-            return upstream_factor
-
-        pressure_ratio = max(downstream_pressure / p, 1.0e-12)
-        isentropic_temperature = max(
-            T * pressure_ratio**isentropic_temperature_exponent,
-            2.2,
-        )
-        downstream_factor, _unused_exponent = (
-            self._local_isentropic_density_pressure_factor(
-                max(downstream_pressure, 1.0),
-                isentropic_temperature,
-            )
-        )
-        # AMESim 2404 saggs_ evaluates the local factor at the upstream
-        # state and at an approximate isentropic downstream state.
-        return 0.5 * (upstream_factor + downstream_factor)
-
-    def pressure(self, m: float, T: float, V: float) -> float:
-        if V <= 0.0:
-            raise ValueError("Volume must stay positive.")
-        return self.fluid.pressure_from_density(T, m / V)
-
-    @profile_property("specific_internal_energy")
-    def specific_internal_energy(self, T: float) -> float:
-        return self.R_gas * (
-            (self.nasa_cp_over_R - 1.0) * T
-            + self.nasa_enthalpy_constant_K
-        )
-
-    @profile_property("specific_internal_energy_at_pressure")
-    def specific_internal_energy_at_pressure(self, p: float, T: float) -> float:
-        density = self.density(p, T)
-        return (
-            self.specific_internal_energy(T)
-            + self.fluid.residual_specific_internal_energy_at_density(T, density)
-        )
-
-    @profile_property("specific_enthalpy")
-    def specific_enthalpy(self, T: float) -> float:
-        return self.R_gas * (
-            self.nasa_cp_over_R * T
-            + self.nasa_enthalpy_constant_K
-        )
-
-    @profile_property("specific_enthalpy_at_pressure")
-    def specific_enthalpy_at_pressure(self, p: float, T: float) -> float:
-        return self.specific_enthalpy(T) + self.fluid.residual_specific_enthalpy(p, T)
-
-    def temperature_from_internal_energy(self, u: float) -> float:
-        return (
-            u / self.R_gas - self.nasa_enthalpy_constant_K
-        ) / (self.nasa_cp_over_R - 1.0)
-
-    def temperature_from_enthalpy(self, h: float) -> float:
-        return (
-            h / self.R_gas - self.nasa_enthalpy_constant_K
-        ) / self.nasa_cp_over_R
-
-    @profile_property("temperature_from_pressure_enthalpy")
-    @cache_property_calculation("temperature_from_pressure_enthalpy")
-    def temperature_from_pressure_enthalpy(self, p: float, h: float) -> float:
-        temperature = max(self.temperature_from_enthalpy(h), 2.2)
-        for _iteration in range(16):
-            residual_enthalpy = self.fluid.residual_specific_enthalpy(p, temperature)
-            next_temperature = max(
-                self.temperature_from_enthalpy(h - residual_enthalpy),
-                2.2,
-            )
-            if abs(next_temperature - temperature) <= 1.0e-10 * max(
-                temperature,
-                1.0,
-            ):
-                record_property_iterations(
-                    "temperature_from_pressure_enthalpy",
-                    _iteration + 1,
-                    True,
-                )
-                return next_temperature
-            temperature = next_temperature
-        record_property_iterations(
-            "temperature_from_pressure_enthalpy",
-            16,
-            False,
-        )
-        return temperature
-
-    def temperature_from_mass_internal_energy(self, m: float, U: float) -> float:
-        if m <= 0.0:
-            raise RecoverableTrialStateError(
-                "Mass must stay positive when recovering temperature."
-            )
-        return self.temperature_from_internal_energy(U / m)
-
-    @profile_property("properties_from_mU")
-    @cache_property_calculation("properties_from_mU")
-    def properties_from_mU(
-        self,
-        m: float,
-        U: float,
-        V: float,
-    ) -> ThermodynamicProperties:
-        """Recover a real-gas state, reusing exact repeated evaluations.
-
-        Implicit integration asks several component interfaces for the same
-        ``(m, U, V)`` state while closing one RHS evaluation and while building
-        finite-difference Jacobians. The calculation is pure and its result is
-        immutable, so an exact-key bounded cache avoids repeating the
-        Peng-Robinson temperature iteration without changing model semantics.
-        """
-        if m <= 0.0:
-            raise RecoverableTrialStateError(
-                "Mass must stay positive when recovering temperature."
-            )
-        if V <= 0.0:
-            raise ValueError("Volume must stay positive.")
-        density = m / V
-        target_internal_energy = U / m
-        temperature = max(
-            self.temperature_from_internal_energy(target_internal_energy),
-            2.2,
-        )
-        converged = False
-        for _iteration in range(16):
-            residual_internal_energy = (
-                self.fluid.residual_specific_internal_energy_at_density(
-                    temperature,
-                    density,
-                )
-            )
-            next_temperature = max(
-                self.temperature_from_internal_energy(
-                    target_internal_energy - residual_internal_energy
-                ),
-                2.2,
-            )
-            if abs(next_temperature - temperature) <= 1.0e-10 * max(
-                temperature,
-                1.0,
-            ):
-                temperature = next_temperature
-                converged = True
-                break
-            temperature = next_temperature
-        record_property_iterations(
-            "properties_from_mU",
-            _iteration + 1,
-            converged,
-        )
-        pressure = self.fluid.pressure_from_density(temperature, density)
-        return ThermodynamicProperties(
-            p=pressure,
-            T=temperature,
-            rho=density,
-            u=target_internal_energy,
-            h=self.specific_enthalpy_at_pressure(
-                pressure,
-                temperature,
-            ),
-        )
-
-    def linearize_properties_from_mU(
-        self,
-        m: float,
-        U: float,
-        V: float,
-        dm: Sequence[float],
-        dU: Sequence[float],
-        dV: Sequence[float],
-        *,
-        properties: ThermodynamicProperties | None = None,
-    ) -> ThermodynamicPropertiesLinearization:
-        """Implicitly differentiate the Peng-Robinson m/U/V recovery."""
-
-        dm_values = tuple(float(value) for value in dm)
-        dU_values = tuple(float(value) for value in dU)
-        dV_values = tuple(float(value) for value in dV)
-        if not (len(dm_values) == len(dU_values) == len(dV_values)):
-            raise ValueError("Thermodynamic tangent vectors must have equal lengths.")
-        props = properties or self.properties_from_mU(m, U, V)
-        width = len(dm_values)
-
-        def invalid(reason: str) -> ThermodynamicPropertiesLinearization:
-            return ThermodynamicPropertiesLinearization(
-                properties=props,
-                tangents=ThermodynamicPropertyTangents.zeros(width),
-                valid=False,
-                reason=reason,
-            )
-
-        expected_density = m / V
-        expected_internal_energy = U / m
-        if (
-            abs(props.rho - expected_density)
-            > 1.0e-12 * max(abs(expected_density), 1.0)
-            or abs(props.u - expected_internal_energy)
-            > 1.0e-12 * max(abs(expected_internal_energy), 1.0)
-        ):
-            return invalid("properties_primal_mismatch")
-        if not all(
-            isfinite(value)
-            for values in (dm_values, dU_values, dV_values)
-            for value in values
-        ):
-            return invalid("non_finite_tangent_input")
-        if props.T <= 2.2 * (1.0 + 1.0e-10):
-            return invalid("temperature_floor_boundary")
-
-        pressure_temperature_derivative = (
-            self.fluid.pressure_temperature_derivative_at_density(
-                props.T,
-                props.rho,
-            )
-        )
-        pressure_density_derivative = (
-            self.fluid.pressure_density_derivative_at_temperature(
-                props.T,
-                props.rho,
-            )
-        )
-        cv = (
-            self.cv_at_temperature(props.T)
-            + self.fluid.residual_isochoric_heat_capacity_at_density(
-                props.T,
-                props.rho,
-            )
-        )
-        recovered_internal_energy = (
-            self.specific_internal_energy(props.T)
-            + self.fluid.residual_specific_internal_energy_at_density(
-                props.T,
-                props.rho,
-            )
-        )
-        recovery_scale = max(
-            abs(props.u),
-            abs(cv * props.T) if isfinite(cv) else 0.0,
-            1.0,
-        )
-        if (
-            not all(
-                isfinite(value)
-                for value in (
-                    pressure_temperature_derivative,
-                    pressure_density_derivative,
-                    cv,
-                    recovered_internal_energy,
-                )
-            )
-            or cv <= 0.0
-        ):
-            return invalid("invalid_peng_robinson_derivative")
-        if abs(recovered_internal_energy - props.u) > 1.0e-8 * recovery_scale:
-            return invalid("properties_recovery_not_converged")
-
-        internal_energy_density_derivative = (
-            props.p - props.T * pressure_temperature_derivative
-        ) / (props.rho * props.rho)
-        drho: list[float] = []
-        du: list[float] = []
-        dT: list[float] = []
-        dp: list[float] = []
-        dh: list[float] = []
-        for mass_tangent, energy_tangent, volume_tangent in zip(
-            dm_values,
-            dU_values,
-            dV_values,
-            strict=True,
-        ):
-            density_tangent = (
-                mass_tangent / V - m * volume_tangent / (V * V)
-            )
-            internal_energy_tangent = (
-                energy_tangent / m - U * mass_tangent / (m * m)
-            )
-            temperature_tangent = (
-                internal_energy_tangent
-                - internal_energy_density_derivative * density_tangent
-            ) / cv
-            pressure_tangent = (
-                pressure_temperature_derivative * temperature_tangent
-                + pressure_density_derivative * density_tangent
-            )
-            enthalpy_tangent = (
-                internal_energy_tangent
-                + pressure_tangent / props.rho
-                - props.p * density_tangent / (props.rho * props.rho)
-            )
-            drho.append(density_tangent)
-            du.append(internal_energy_tangent)
-            dT.append(temperature_tangent)
-            dp.append(pressure_tangent)
-            dh.append(enthalpy_tangent)
-
-        tangent_values = (*drho, *du, *dT, *dp, *dh)
-        if not all(isfinite(value) for value in tangent_values):
-            return invalid("non_finite_property_tangent")
-        return ThermodynamicPropertiesLinearization(
-            properties=props,
-            tangents=ThermodynamicPropertyTangents(
-                p=tuple(dp),
-                T=tuple(dT),
-                rho=tuple(drho),
-                u=tuple(du),
-                h=tuple(dh),
-            ),
-        )
-
-
 @dataclass(frozen=True)
 class AmesimGasPropertyModelSpec:
     """A selectable calculation method for one AMESim gas substance."""
-
     value: int
     label: str
     method_id: str
@@ -491,27 +45,7 @@ class AmesimGasPropertyModelSpec:
 
     def build_medium(self) -> GasMedium:
         return self.factory()
-
-
 AMESIM_AIR_IDEAL_GAS_PROPERTY_MODEL = 0
-AMESIM_AIR_PROPERTY_MODELS = (
-    AmesimGasPropertyModelSpec(
-        value=AMESIM_AIR_IDEAL_GAS_PROPERTY_MODEL,
-        label="理想气体",
-        method_id=AmesimIdealAirMedium.PROPERTY_METHOD_ID,
-        factory=AmesimIdealAirMedium,
-        eos_type=1,
-    ),
-)
-
-
+AMESIM_AIR_PROPERTY_MODELS = (AmesimGasPropertyModelSpec(value=AMESIM_AIR_IDEAL_GAS_PROPERTY_MODEL, label='理想气体', method_id=AmesimIdealAirMedium.PROPERTY_METHOD_ID, factory=AmesimIdealAirMedium, eos_type=1),)
 AMESIM_HELIUM_PENG_ROBINSON_PROPERTY_MODEL = 0
-AMESIM_HELIUM_PROPERTY_MODELS = (
-    AmesimGasPropertyModelSpec(
-        value=AMESIM_HELIUM_PENG_ROBINSON_PROPERTY_MODEL,
-        label="Peng–Robinson",
-        method_id=AmesimHeliumPengRobinsonMedium.PROPERTY_METHOD_ID,
-        factory=AmesimHeliumPengRobinsonMedium,
-        eos_type=6,
-    ),
-)
+AMESIM_HELIUM_PROPERTY_MODELS = (AmesimGasPropertyModelSpec(value=AMESIM_HELIUM_PENG_ROBINSON_PROPERTY_MODEL, label='Peng–Robinson', method_id=AmesimHeliumPengRobinsonMedium.PROPERTY_METHOD_ID, factory=AmesimHeliumPengRobinsonMedium, eos_type=6),)

app/simulation/components/amesim/signals/sources.py

@@ -1,355 +1,79 @@
+"""Component parameters, ports and output definitions; numerical equations execute in C."""
 from __future__ import annotations
-
 from collections.abc import Mapping
-from math import floor
-
 from app.simulation.core.base import AlgebraicComponent
-from app.simulation.core.catalog import (
-    ComponentDisplaySpec,
-    ParameterGroupDisplaySpec,
-    PortDisplaySpec,
-)
-from app.simulation.core.metadata import (
-    ParameterCondition,
-    ParameterDefinition,
-    ParameterOption,
-    ResultVariableDefinition,
-)
+from app.simulation.core.catalog import ComponentDisplaySpec, ParameterGroupDisplaySpec, PortDisplaySpec
+from app.simulation.core.metadata import ParameterCondition, ParameterDefinition, ParameterOption, ResultVariableDefinition
 from app.simulation.core.medium import IdealGasMedium
 from app.simulation.core.ports import PortDefinition
-
-
 def _ud00_stage_parameters(index: int) -> tuple[ParameterDefinition, ...]:
-    visible_when = (
-        ()
-        if index == 1
-        else (
-            ParameterCondition(
-                "nstages",
-                tuple(float(stage_count) for stage_count in range(index, 9)),
-            ),
-        )
-    )
-    return (
-        ParameterDefinition(
-            f"start{index}",
-            0.0 if index == 1 else 1.0,
-            label=f"第 {index} 段起点",
-            quantity="dimensionless",
-            unit="",
-            description=f"第 {index} 段开始时的输出值。",
-            visible_when=visible_when,
-        ),
-        ParameterDefinition(
-            f"end{index}",
-            1.0,
-            label=f"第 {index} 段终点",
-            quantity="dimensionless",
-            unit="",
-            description=f"第 {index} 段结束时的输出值。",
-            visible_when=visible_when,
-        ),
-        ParameterDefinition(
-            f"t{index}",
-            1.0 if index == 1 else 0.0,
-            label=f"第 {index} 段时长",
-            quantity="time",
-            unit="s",
-            minimum=0.0,
-            description=f"第 {index} 段的持续时间。",
-            visible_when=visible_when,
-        ),
-    )
-
-
-_UD00_STAGE_PARAMETERS = tuple(
-    parameter
-    for stage_index in range(1, 9)
-    for parameter in _ud00_stage_parameters(stage_index)
-)
+    visible_when = () if index == 1 else (ParameterCondition('nstages', tuple((float(stage_count) for stage_count in range(index, 9)))),)
+    return (ParameterDefinition(f'start{index}', 0.0 if index == 1 else 1.0, label=f'第 {index} 段起点', quantity='dimensionless', unit='', description=f'第 {index} 段开始时的输出值。', visible_when=visible_when), ParameterDefinition(f'end{index}', 1.0, label=f'第 {index} 段终点', quantity='dimensionless', unit='', description=f'第 {index} 段结束时的输出值。', visible_when=visible_when), ParameterDefinition(f't{index}', 1.0 if index == 1 else 0.0, label=f'第 {index} 段时长', quantity='time', unit='s', minimum=0.0, description=f'第 {index} 段的持续时间。', visible_when=visible_when))
 
+_UD00_STAGE_PARAMETERS = tuple((parameter for stage_index in range(1, 9) for parameter in _ud00_stage_parameters(stage_index)))
 
 class AmesimStep0(AlgebraicComponent):
     """AMESim STEP0 scalar step signal source."""
+    MODEL_TYPE = 'amesim_step0'
+    MODEL_VERSION = '0.1.0'
+    PORTS = (PortDefinition.signal('out', nominal_role='output'),)
+    PARAMETERS = (ParameterDefinition('initial', 0.0, label='初始值', quantity='dimensionless', unit=''), ParameterDefinition('final', 1.0, label='阶跃后值', quantity='dimensionless', unit=''), ParameterDefinition('time', 0.0, label='阶跃时间', quantity='time', unit='s'))
+    RESULT_VARIABLES = (ResultVariableDefinition('y', '输出', 'dimensionless', '', 'signal', 10),)
+    DISPLAY = ComponentDisplaySpec(label='STEP0 阶跃信号', library_id='amesim', category_id='signals', symbol='amesim_step0', ports=(PortDisplaySpec('out', 'right', order=10),), order=10)
 
-    MODEL_TYPE = "amesim_step0"
-    MODEL_VERSION = "0.1.0"
-    PORTS = (PortDefinition.signal("out", nominal_role="output"),)
-    PARAMETERS = (
-        ParameterDefinition("initial", 0.0, label="初始值", quantity="dimensionless", unit=""),
-        ParameterDefinition("final", 1.0, label="阶跃后值", quantity="dimensionless", unit=""),
-        ParameterDefinition("time", 0.0, label="阶跃时间", quantity="time", unit="s"),
-    )
-    RESULT_VARIABLES = (
-        ResultVariableDefinition("y", "输出", "dimensionless", "", "signal", 10),
-    )
-    DISPLAY = ComponentDisplaySpec(
-        label="STEP0 阶跃信号",
-        library_id="amesim",
-        category_id="signals",
-        symbol="amesim_step0",
-        ports=(PortDisplaySpec("out", "right", order=10),),
-        order=10,
-    )
-
-    def __init__(
-        self,
-        name: str,
-        medium: IdealGasMedium,
-        *,
-        initial: float = 0.0,
-        final: float = 1.0,
-        time: float = 0.0,
-    ) -> None:
+    def __init__(self, name: str, medium: IdealGasMedium, *, initial: float=0.0, final: float=1.0, time: float=0.0) -> None:
         super().__init__(name=name)
-        self.set_parameter_values({"initial": initial, "final": final, "time": time})
+        self.set_parameter_values({'initial': initial, 'final': final, 'time': time})
         self.initial = float(initial)
         self.final = float(final)
         self.time = float(time)
-        self.out = self.register_declared_port("out")
-        self.out.signal = self.output_at(0.0)
+        self.out = self.register_declared_port('out')
 
     @classmethod
-    def create(
-        cls,
-        *,
-        name: str,
-        medium: IdealGasMedium,
-        parameters: Mapping[str, float],
-    ) -> "AmesimStep0":
-        return cls(
-            name=name,
-            medium=medium,
-            initial=parameters["initial"],
-            final=parameters["final"],
-            time=parameters["time"],
-        )
-
-    def output_at(self, time: float) -> float:
-        return self.final if time >= self.time else self.initial
-
-    def signal_output_values(self, time: float) -> dict[str, float]:
-        return {"out": self.output_at(time)}
-
-    def signal_event_times(
-        self,
-        start_time: float,
-        stop_time: float,
-    ) -> tuple[float, ...]:
-        """Expose the exact STEP0 switch time as an integration split point."""
-
-        return (self.time,) if start_time < self.time < stop_time else ()
-
-    def component_result_values(self) -> Mapping[str, float]:
-        return {"y": self.out.signal}
-
+    def create(cls, *, name: str, medium: IdealGasMedium, parameters: Mapping[str, float]) -> 'AmesimStep0':
+        return cls(name=name, medium=medium, initial=parameters['initial'], final=parameters['final'], time=parameters['time'])
+    EQUATIONS = ()
 
 class AmesimUd00(AlgebraicComponent):
     """AMESim UD00 piecewise-linear scalar signal source."""
+    MODEL_TYPE = 'amesim_ud00'
+    MODEL_VERSION = '0.2.0'
+    PORTS = (PortDefinition.signal('out', nominal_role='output'),)
+    PARAMETERS = (ParameterDefinition('tstart', 0.0, label='启动时间', quantity='time', unit='s', description='分段信号开始输出第一段之前的等待时间。'), *_UD00_STAGE_PARAMETERS, ParameterDefinition('nstages', 1.0, label='段数', quantity='dimensionless', unit='', minimum=1.0, maximum=8.0, editor='choice', options=tuple((ParameterOption(float(stage_count), str(stage_count)) for stage_count in range(1, 9))), description='参与输出计算的有效线性分段数量。'), ParameterDefinition('iscyclic', 0.0, label='循环', quantity='dimensionless', unit='', minimum=0.0, maximum=1.0, editor='choice', options=(ParameterOption(0.0, '否'), ParameterOption(1.0, '是')), description='当前公共协议编码：0 表示单次输出，1 表示循环输出。'))
+    RESULT_VARIABLES = (ResultVariableDefinition('y', '输出', 'dimensionless', '', 'signal', 10),)
+    DISPLAY = ComponentDisplaySpec(label='UD00 分段线性信号', library_id='amesim', category_id='signals', symbol='amesim_ud00', ports=(PortDisplaySpec('out', 'right', order=10),), order=20, parameter_groups=(ParameterGroupDisplaySpec(id='stages', label='分段参数', parameters=tuple((parameter.name for parameter in _UD00_STAGE_PARAMETERS)), order=10),))
 
-    MODEL_TYPE = "amesim_ud00"
-    MODEL_VERSION = "0.2.0"
-    PORTS = (PortDefinition.signal("out", nominal_role="output"),)
-    PARAMETERS = (
-        ParameterDefinition(
-            "tstart",
-            0.0,
-            label="启动时间",
-            quantity="time",
-            unit="s",
-            description="分段信号开始输出第一段之前的等待时间。",
-        ),
-        *_UD00_STAGE_PARAMETERS,
-        ParameterDefinition(
-            "nstages",
-            1.0,
-            label="段数",
-            quantity="dimensionless",
-            unit="",
-            minimum=1.0,
-            maximum=8.0,
-            editor="choice",
-            options=tuple(
-                ParameterOption(float(stage_count), str(stage_count))
-                for stage_count in range(1, 9)
-            ),
-            description="参与输出计算的有效线性分段数量。",
-        ),
-        ParameterDefinition(
-            "iscyclic",
-            0.0,
-            label="循环",
-            quantity="dimensionless",
-            unit="",
-            minimum=0.0,
-            maximum=1.0,
-            editor="choice",
-            options=(
-                ParameterOption(0.0, "否"),
-                ParameterOption(1.0, "是"),
-            ),
-            description="当前公共协议编码：0 表示单次输出，1 表示循环输出。",
-        ),
-    )
-    RESULT_VARIABLES = (
-        ResultVariableDefinition("y", "输出", "dimensionless", "", "signal", 10),
-    )
-    DISPLAY = ComponentDisplaySpec(
-        label="UD00 分段线性信号",
-        library_id="amesim",
-        category_id="signals",
-        symbol="amesim_ud00",
-        ports=(PortDisplaySpec("out", "right", order=10),),
-        order=20,
-        parameter_groups=(
-            ParameterGroupDisplaySpec(
-                id="stages",
-                label="分段参数",
-                parameters=tuple(
-                    parameter.name for parameter in _UD00_STAGE_PARAMETERS
-                ),
-                order=10,
-            ),
-        ),
-    )
-
-    def __init__(
-        self,
-        name: str,
-        medium: IdealGasMedium,
-        *,
-        tstart: float = 0.0,
-        starts: tuple[float, ...] = (0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0),
-        ends: tuple[float, ...] = (1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0),
-        durations: tuple[float, ...] = (1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0),
-        nstages: int = 1,
-        iscyclic: bool = False,
-    ) -> None:
+    def __init__(self, name: str, medium: IdealGasMedium, *, tstart: float=0.0, starts: tuple[float, ...]=(0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0), ends: tuple[float, ...]=(1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0), durations: tuple[float, ...]=(1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0), nstages: int=1, iscyclic: bool=False) -> None:
         super().__init__(name=name)
         if len(starts) != 8 or len(ends) != 8 or len(durations) != 8:
-            raise ValueError("UD00 requires exactly eight start, end, and duration values.")
+            raise ValueError('UD00 requires exactly eight start, end, and duration values.')
         if nstages < 1 or nstages > 8:
-            raise ValueError("UD00 nstages must be between 1 and 8.")
+            raise ValueError('UD00 nstages must be between 1 and 8.')
         self.tstart = float(tstart)
-        self.starts = tuple(float(value) for value in starts)
-        self.ends = tuple(float(value) for value in ends)
-        self.durations = tuple(float(value) for value in durations)
+        self.starts = tuple((float(value) for value in starts))
+        self.ends = tuple((float(value) for value in ends))
+        self.durations = tuple((float(value) for value in durations))
         self.nstages = int(nstages)
         self.iscyclic = bool(iscyclic)
-        values: dict[str, float] = {"tstart": self.tstart, "nstages": float(self.nstages), "iscyclic": float(int(self.iscyclic))}
+        values: dict[str, float] = {'tstart': self.tstart, 'nstages': float(self.nstages), 'iscyclic': float(int(self.iscyclic))}
         for index in range(1, 9):
-            values[f"start{index}"] = self.starts[index - 1]
-            values[f"end{index}"] = self.ends[index - 1]
-            values[f"t{index}"] = self.durations[index - 1]
+            values[f'start{index}'] = self.starts[index - 1]
+            values[f'end{index}'] = self.ends[index - 1]
+            values[f't{index}'] = self.durations[index - 1]
         self.set_parameter_values(values)
-        self.out = self.register_declared_port("out")
-        self.out.signal = self.output_at(0.0)
+        self.out = self.register_declared_port('out')
 
     @classmethod
-    def create(
-        cls,
-        *,
-        name: str,
-        medium: IdealGasMedium,
-        parameters: Mapping[str, float],
-    ) -> "AmesimUd00":
-        nstages = parameters["nstages"]
-        iscyclic = parameters["iscyclic"]
+    def create(cls, *, name: str, medium: IdealGasMedium, parameters: Mapping[str, float]) -> 'AmesimUd00':
+        nstages = parameters['nstages']
+        iscyclic = parameters['iscyclic']
         definitions = {definition.name: definition for definition in cls.PARAMETERS}
-        for parameter_name, value in (
-            ("nstages", nstages),
-            ("iscyclic", iscyclic),
-        ):
+        for parameter_name, value in (('nstages', nstages), ('iscyclic', iscyclic)):
             numeric_value = float(value)
             if not numeric_value.is_integer():
-                raise ValueError(f"UD00 {parameter_name} must be an integer.")
+                raise ValueError(f'UD00 {parameter_name} must be an integer.')
             message = definitions[parameter_name].validation_message(numeric_value)
             if message is not None:
-                raise ValueError(f"UD00 {parameter_name} {message}.")
-        return cls(
-            name=name,
-            medium=medium,
-            tstart=parameters["tstart"],
-            starts=tuple(parameters[f"start{index}"] for index in range(1, 9)),
-            ends=tuple(parameters[f"end{index}"] for index in range(1, 9)),
-            durations=tuple(parameters[f"t{index}"] for index in range(1, 9)),
-            nstages=int(nstages),
-            iscyclic=bool(int(iscyclic)),
-        )
-
-    def output_at(self, time: float) -> float:
-        elapsed = max(float(time) - self.tstart, 0.0)
-        active_durations = self.durations[: self.nstages]
-        total_duration = sum(active_durations)
-        if self.iscyclic and total_duration > 0.0:
-            elapsed = elapsed % total_duration
-
-        stage_start_time = 0.0
-        for index, duration in enumerate(active_durations):
-            stage_end_time = stage_start_time + duration
-            if elapsed < stage_end_time or index == self.nstages - 1:
-                if duration <= 0.0:
-                    return self.ends[index]
-                fraction = (elapsed - stage_start_time) / duration
-                return self.starts[index] + fraction * (self.ends[index] - self.starts[index])
-            stage_start_time = stage_end_time
-        return self.ends[self.nstages - 1]
-
-    def signal_output_values(self, time: float) -> dict[str, float]:
-        return {"out": self.output_at(time)}
-
-    def signal_event_times(
-        self,
-        start_time: float,
-        stop_time: float,
-    ) -> tuple[float, ...]:
-        """Return UD00 start, stage, and repeated cycle boundaries.
-
-        The final non-cyclic stage is intentionally not given an end event:
-        ``output_at`` continues that stage's slope after its configured duration.
-        """
-
-        if stop_time <= start_time:
-            return ()
-
-        active_durations = self.durations[: self.nstages]
-        stage_offsets = [0.0]
-        elapsed = 0.0
-        for duration in active_durations[:-1]:
-            elapsed += duration
-            stage_offsets.append(elapsed)
-
-        if not self.iscyclic:
-            return tuple(
-                sorted(
-                    {
-                        event_time
-                        for offset in stage_offsets
-                        if start_time
-                        < (event_time := self.tstart + offset)
-                        < stop_time
-                    }
-                )
-            )
-
-        cycle_duration = sum(active_durations)
-        if cycle_duration <= 0.0:
-            return ()
-
-        events: set[float] = set()
-        for offset in stage_offsets:
-            first_boundary = self.tstart + offset
-            cycle_index = max(
-                0,
-                floor((start_time - first_boundary) / cycle_duration) + 1,
-            )
-            event_time = first_boundary + cycle_index * cycle_duration
-            while event_time < stop_time:
-                if event_time > start_time:
-                    events.add(event_time)
-                cycle_index += 1
-                event_time = first_boundary + cycle_index * cycle_duration
-        return tuple(sorted(events))
-
-    def component_result_values(self) -> Mapping[str, float]:
-        return {"y": self.out.signal}
+                raise ValueError(f'UD00 {parameter_name} {message}.')
+        return cls(name=name, medium=medium, tstart=parameters['tstart'], starts=tuple((parameters[f'start{index}'] for index in range(1, 9))), ends=tuple((parameters[f'end{index}'] for index in range(1, 9))), durations=tuple((parameters[f't{index}'] for index in range(1, 9))), nstages=int(nstages), iscyclic=bool(int(iscyclic)))
+    EQUATIONS = ()

app/simulation/components/amesim/storage/chambers.py

@@ -1,38 +1,12 @@
+"""Component parameters, ports and output definitions; numerical equations execute in C."""
 from __future__ import annotations
-
-from collections.abc import Mapping, Sequence
-from dataclasses import dataclass
-from math import isfinite
-
-from app.simulation.components.amesim.gases import (
-    AMESIM_GAS_INDEX_PARAMETER,
-    normalize_amesim_gas_index,
-)
+from collections.abc import Mapping
+from app.simulation.components.amesim.gases import AMESIM_GAS_INDEX_PARAMETER, normalize_amesim_gas_index
 from app.simulation.core.base import ThermodynamicVolumeComponent
 from app.simulation.core.catalog import ComponentDisplaySpec, PortDisplaySpec
-from app.simulation.core.equations import EquationResidual
-from app.simulation.core.metadata import (
-    ParameterDefinition,
-    ResultVariableDefinition,
-    THERMODYNAMIC_VOLUME_RESULT_VARIABLES,
-)
-from app.simulation.core.medium import (
-    GasMedium,
-    ThermodynamicProperties,
-    ThermodynamicPropertiesLinearization,
-)
+from app.simulation.core.metadata import ParameterDefinition, ResultVariableDefinition, THERMODYNAMIC_VOLUME_RESULT_VARIABLES
+from app.simulation.core.medium import GasMedium
 from app.simulation.core.ports import PortDefinition
-from app.simulation.core.state import VolumeState
-
-
-@dataclass(frozen=True)
-class Pnch012DerivativeLinearization:
-    derivative: tuple[float, float]
-    tangents: tuple[tuple[float, ...], tuple[float, ...]]
-    properties: ThermodynamicPropertiesLinearization
-    valid: bool = True
-    reason: str | None = None
-
 
 class AmesimPnch023(ThermodynamicVolumeComponent):
     """AMESim PNCH023 simple pneumatic chamber with heat exchange.
@@ -42,112 +16,16 @@ class AmesimPnch023(ThermodynamicVolumeComponent):
     framework's mass/internal-energy volume state and keeps the AMESim
     heat-transfer contract `kth * sth * (extemp - T)`.
     """
-
-    MODEL_TYPE = "amesim_pnch023"
-    MODEL_VERSION = "0.1.0"
-    PORTS = (
-        PortDefinition.pneumatic("port_1", nominal_role="bidirectional"),
-        PortDefinition.pneumatic("port_2", nominal_role="bidirectional"),
-    )
-    PARAMETERS = (
-        AMESIM_GAS_INDEX_PARAMETER,
-        ParameterDefinition(
-            "cvol",
-            0.057,
-            label="气室容积",
-            quantity="volume",
-            unit="m3",
-            minimum=0.0,
-            minimum_exclusive=True,
-            description="气室内部用于储存气体的固定有效容积。",
-        ),
-        ParameterDefinition(
-            "kth",
-            0.0,
-            label="换热系数",
-            quantity="heat_transfer_coefficient",
-            unit="W/(m2*K)",
-            minimum=0.0,
-            description="气室与环境之间的对流换热系数，与换热面积共同决定换热功率。",
-        ),
-        ParameterDefinition(
-            "sth",
-            0.1,
-            label="换热面积",
-            quantity="area",
-            unit="m2",
-            minimum=0.0,
-            description="气室与环境进行热交换的有效表面积。",
-        ),
-        ParameterDefinition(
-            "extemp",
-            293.15,
-            label="外部温度",
-            quantity="temperature",
-            unit="K",
-            minimum=0.0,
-            minimum_exclusive=True,
-            description="气室外部环境的绝对温度，用于计算气体与环境之间的换热。",
-        ),
-        ParameterDefinition(
-            "p0",
-            100000.0,
-            label="初始压力",
-            quantity="pressure",
-            unit="Pa",
-            minimum=0.0,
-            minimum_exclusive=True,
-            description="仿真开始时气室内气体的绝对压力。",
-        ),
-        ParameterDefinition(
-            "T0",
-            293.15,
-            label="初始温度",
-            quantity="temperature",
-            unit="K",
-            minimum=0.0,
-            minimum_exclusive=True,
-            description="仿真开始时气室内气体的绝对温度。",
-        ),
-    )
+    MODEL_TYPE = 'amesim_pnch023'
+    MODEL_VERSION = '0.1.0'
+    PORTS = (PortDefinition.pneumatic('port_1', nominal_role='bidirectional'), PortDefinition.pneumatic('port_2', nominal_role='bidirectional'))
+    PARAMETERS = (AMESIM_GAS_INDEX_PARAMETER, ParameterDefinition('cvol', 0.057, label='气室容积', quantity='volume', unit='m3', minimum=0.0, minimum_exclusive=True, description='气室内部用于储存气体的固定有效容积。'), ParameterDefinition('kth', 0.0, label='换热系数', quantity='heat_transfer_coefficient', unit='W/(m2*K)', minimum=0.0, description='气室与环境之间的对流换热系数，与换热面积共同决定换热功率。'), ParameterDefinition('sth', 0.1, label='换热面积', quantity='area', unit='m2', minimum=0.0, description='气室与环境进行热交换的有效表面积。'), ParameterDefinition('extemp', 293.15, label='外部温度', quantity='temperature', unit='K', minimum=0.0, minimum_exclusive=True, description='气室外部环境的绝对温度，用于计算气体与环境之间的换热。'), ParameterDefinition('p0', 100000.0, label='初始压力', quantity='pressure', unit='Pa', minimum=0.0, minimum_exclusive=True, description='仿真开始时气室内气体的绝对压力。'), ParameterDefinition('T0', 293.15, label='初始温度', quantity='temperature', unit='K', minimum=0.0, minimum_exclusive=True, description='仿真开始时气室内气体的绝对温度。'))
     RESULT_VARIABLES = THERMODYNAMIC_VOLUME_RESULT_VARIABLES
-    DISPLAY = ComponentDisplaySpec(
-        label="PNCH023 固定容积气室",
-        library_id="amesim",
-        category_id="storage",
-        symbol="amesim_pnch023",
-        ports=(
-            PortDisplaySpec("port_1", "left", order=10),
-            PortDisplaySpec("port_2", "right", order=20),
-        ),
-        order=10,
-    )
+    DISPLAY = ComponentDisplaySpec(label='PNCH023 固定容积气室', library_id='amesim', category_id='storage', symbol='amesim_pnch023', ports=(PortDisplaySpec('port_1', 'left', order=10), PortDisplaySpec('port_2', 'right', order=20)), order=10)
 
-    def __init__(
-        self,
-        name: str,
-        medium: GasMedium,
-        *,
-        cvol: float = 0.057,
-        kth: float = 0.0,
-        sth: float = 0.1,
-        extemp: float = 293.15,
-        gi: float = 1.0,
-        p0: float = 100000.0,
-        T0: float = 293.15,
-    ) -> None:
+    def __init__(self, name: str, medium: GasMedium, *, cvol: float=0.057, kth: float=0.0, sth: float=0.1, extemp: float=293.15, gi: float=1.0, p0: float=100000.0, T0: float=293.15) -> None:
         super().__init__(name=name)
-        self.set_parameter_values(
-            {
-                "cvol": cvol,
-                "kth": kth,
-                "sth": sth,
-                "extemp": extemp,
-                "gi": gi,
-                "p0": p0,
-                "T0": T0,
-            }
-        )
+        self.set_parameter_values({'cvol': cvol, 'kth': kth, 'sth': sth, 'extemp': extemp, 'gi': gi, 'p0': p0, 'T0': T0})
         self.medium = medium
         self.cvol = float(cvol)
         self.kth = float(kth)
@@ -156,120 +34,13 @@ class AmesimPnch023(ThermodynamicVolumeComponent):
         self.gi = normalize_amesim_gas_index(gi)
         self.p0 = float(p0)
         self.T0 = float(T0)
-        m0 = medium.density(self.p0, self.T0) * self.cvol
-        U0 = m0 * medium.specific_internal_energy_at_pressure(self.p0, self.T0)
-        self.state = VolumeState(m=m0, U=U0)
-        initial_h = medium.specific_enthalpy_at_pressure(self.p0, self.T0)
-        self.port_1 = self.register_declared_port("port_1")
-        self.port_1.p = self.p0
-        self.port_1.h_outflow = initial_h
-        self.port_2 = self.register_declared_port("port_2")
-        self.port_2.p = self.p0
-        self.port_2.h_outflow = initial_h
+        self.port_1 = self.register_declared_port('port_1')
+        self.port_2 = self.register_declared_port('port_2')
 
     @classmethod
-    def create(
-        cls,
-        *,
-        name: str,
-        medium: GasMedium,
-        parameters: Mapping[str, float],
-    ) -> AmesimPnch023:
-        return cls(
-            name=name,
-            medium=medium,
-            cvol=parameters["cvol"],
-            kth=parameters["kth"],
-            sth=parameters["sth"],
-            extemp=parameters["extemp"],
-            gi=parameters["gi"],
-            p0=parameters["p0"],
-            T0=parameters["T0"],
-        )
-
-    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 properties(self) -> ThermodynamicProperties:
-        props = self.medium.properties_from_mU(self.state.m, self.state.U, self.cvol)
-        self.port_1.p = props.p
-        self.port_1.h_outflow = props.h
-        self.port_2.p = props.p
-        self.port_2.h_outflow = props.h
-        return props
-
-    def refresh_thermodynamic_ports(self) -> ThermodynamicProperties:
-        return self.properties()
-
-    def thermal_energy_flow_w(self, temperature: float) -> float:
-        return self.kth * self.sth * (self.extemp - temperature)
-
-    def state_derivative_from_ports(
-        self,
-        connected_h: Mapping[str, float],
-    ) -> list[float]:
-        props = self.properties()
-        inlet_h_1 = self.connection_inlet_enthalpy(
-            port_m_flow=self.port_1.m_flow,
-            connected_h=connected_h["port_1"],
-            internal_h=props.h,
-        )
-        inlet_h_2 = self.connection_inlet_enthalpy(
-            port_m_flow=self.port_2.m_flow,
-            connected_h=connected_h["port_2"],
-            internal_h=props.h,
-        )
-        derivative = VolumeState(
-            m=self.port_1.m_flow + self.port_2.m_flow,
-            U=(
-                self.port_1.m_flow * inlet_h_1
-                + self.port_2.m_flow * inlet_h_2
-                + self.thermal_energy_flow_w(props.T)
-            ),
-        )
-        return derivative.as_vector()
-
-    def pressure_flow_equation_values(self) -> tuple[float, ...]:
-        pressure = self.medium.properties_from_mU(
-            self.state.m,
-            self.state.U,
-            self.cvol,
-        ).p
-        return (
-            self.port_1.p - pressure,
-            self.port_2.p - pressure,
-        )
-
-    def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
-        pressure = self.medium.properties_from_mU(
-            self.state.m,
-            self.state.U,
-            self.cvol,
-        ).p
-        return (
-            EquationResidual(
-                id=f"{self.name}:port_1_pressure_state",
-                owner="component",
-                owner_id=self.name,
-                relation="state",
-                variables=(f"{self.name}.port_1.p", f"{self.name}.state"),
-                role="effort",
-                value=self.port_1.p - pressure,
-            ),
-            EquationResidual(
-                id=f"{self.name}:port_2_pressure_state",
-                owner="component",
-                owner_id=self.name,
-                relation="state",
-                variables=(f"{self.name}.port_2.p", f"{self.name}.state"),
-                role="effort",
-                value=self.port_2.p - pressure,
-            ),
-        )
-
+    def create(cls, *, name: str, medium: GasMedium, parameters: Mapping[str, float]) -> AmesimPnch023:
+        return cls(name=name, medium=medium, cvol=parameters['cvol'], kth=parameters['kth'], sth=parameters['sth'], extemp=parameters['extemp'], gi=parameters['gi'], p0=parameters['p0'], T0=parameters['T0'])
+    EQUATIONS = ({'id': '__MODEL__:port_1_pressure_state', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'state', 'variables': ['__MODEL__.port_1.p', '__MODEL__.state'], 'role': 'effort'}, {'id': '__MODEL__:port_2_pressure_state', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'state', 'variables': ['__MODEL__.port_2.p', '__MODEL__.state'], 'role': 'effort'})
 
 class AmesimPnch012(ThermodynamicVolumeComponent):
     """AMESim PNCH012 variable-volume pneumatic chamber.
@@ -279,143 +50,16 @@ class AmesimPnch012(ThermodynamicVolumeComponent):
     parameters, while connected moving-boundary components can now add live
     volume and volume-rate values through the pneumatic connector contract.
     """
+    MODEL_TYPE = 'amesim_pnch012'
+    MODEL_VERSION = '0.1.0'
+    PORTS = (PortDefinition.pneumatic('port_1', nominal_role='bidirectional'), PortDefinition.pneumatic('port_2', nominal_role='bidirectional'), PortDefinition.pneumatic('port_3', nominal_role='bidirectional'), PortDefinition.pneumatic('port_4', nominal_role='bidirectional'))
+    PARAMETERS = (AMESIM_GAS_INDEX_PARAMETER, ParameterDefinition('cvol0', 0.015, label='死容积', quantity='volume', unit='m3', minimum=0.0, minimum_exclusive=True, description='变容气室在所有外部容积为零时仍保留的基础容积。'), ParameterDefinition('kth', 0.0, label='换热系数', quantity='heat_transfer_coefficient', unit='W/(m2*K)', minimum=0.0, description='气室与环境之间的对流换热系数，与换热面积共同决定换热功率。'), ParameterDefinition('sth', 0.1, label='换热面积', quantity='area', unit='m2', minimum=0.0, description='气室与环境进行热交换的有效表面积。'), ParameterDefinition('extemp', 293.15, label='外部温度', quantity='temperature', unit='K', minimum=0.0, minimum_exclusive=True, description='气室外部环境的绝对温度，用于计算气体与环境之间的换热。'), ParameterDefinition('p0', 100000.0, label='初始压力', quantity='pressure', unit='Pa', minimum=0.0, minimum_exclusive=True, description='仿真开始时气室内气体的绝对压力。'), ParameterDefinition('T0', 293.15, label='初始温度', quantity='temperature', unit='K', minimum=0.0, minimum_exclusive=True, description='仿真开始时气室内气体的绝对温度。'), ParameterDefinition('vol1', 0.0, label='端口 1 外部容积', quantity='volume', unit='m3'), ParameterDefinition('vol2', 0.0, label='端口 2 外部容积', quantity='volume', unit='m3'), ParameterDefinition('vol3', 0.0, label='端口 3 外部容积', quantity='volume', unit='m3'), ParameterDefinition('vol4', 0.0, label='端口 4 外部容积', quantity='volume', unit='m3'), ParameterDefinition('dvol1', 0.0, label='端口 1 容积变化率', quantity='volume_flow', unit='m3/s'), ParameterDefinition('dvol2', 0.0, label='端口 2 容积变化率', quantity='volume_flow', unit='m3/s'), ParameterDefinition('dvol3', 0.0, label='端口 3 容积变化率', quantity='volume_flow', unit='m3/s'), ParameterDefinition('dvol4', 0.0, label='端口 4 容积变化率', quantity='volume_flow', unit='m3/s'))
+    RESULT_VARIABLES = THERMODYNAMIC_VOLUME_RESULT_VARIABLES + (ResultVariableDefinition('vol', '气室总容积', 'volume', 'm3', 'derived', 100), ResultVariableDefinition('dvol', '总容积变化率', 'volume_flow', 'm3/s', 'derived', 110))
+    DISPLAY = ComponentDisplaySpec(label='PNCH012 变容气室', library_id='amesim', category_id='storage', symbol='amesim_pnch012', ports=(PortDisplaySpec('port_1', 'left', order=10), PortDisplaySpec('port_2', 'right', order=20), PortDisplaySpec('port_3', 'left', order=30), PortDisplaySpec('port_4', 'right', order=40)), order=20)
 
-    MODEL_TYPE = "amesim_pnch012"
-    MODEL_VERSION = "0.1.0"
-    PORTS = (
-        PortDefinition.pneumatic("port_1", nominal_role="bidirectional"),
-        PortDefinition.pneumatic("port_2", nominal_role="bidirectional"),
-        PortDefinition.pneumatic("port_3", nominal_role="bidirectional"),
-        PortDefinition.pneumatic("port_4", nominal_role="bidirectional"),
-    )
-    PARAMETERS = (
-        AMESIM_GAS_INDEX_PARAMETER,
-        ParameterDefinition(
-            "cvol0",
-            0.015,
-            label="死容积",
-            quantity="volume",
-            unit="m3",
-            minimum=0.0,
-            minimum_exclusive=True,
-            description="变容气室在所有外部容积为零时仍保留的基础容积。",
-        ),
-        ParameterDefinition(
-            "kth",
-            0.0,
-            label="换热系数",
-            quantity="heat_transfer_coefficient",
-            unit="W/(m2*K)",
-            minimum=0.0,
-            description="气室与环境之间的对流换热系数，与换热面积共同决定换热功率。",
-        ),
-        ParameterDefinition(
-            "sth",
-            0.1,
-            label="换热面积",
-            quantity="area",
-            unit="m2",
-            minimum=0.0,
-            description="气室与环境进行热交换的有效表面积。",
-        ),
-        ParameterDefinition(
-            "extemp",
-            293.15,
-            label="外部温度",
-            quantity="temperature",
-            unit="K",
-            minimum=0.0,
-            minimum_exclusive=True,
-            description="气室外部环境的绝对温度，用于计算气体与环境之间的换热。",
-        ),
-        ParameterDefinition(
-            "p0",
-            100000.0,
-            label="初始压力",
-            quantity="pressure",
-            unit="Pa",
-            minimum=0.0,
-            minimum_exclusive=True,
-            description="仿真开始时气室内气体的绝对压力。",
-        ),
-        ParameterDefinition(
-            "T0",
-            293.15,
-            label="初始温度",
-            quantity="temperature",
-            unit="K",
-            minimum=0.0,
-            minimum_exclusive=True,
-            description="仿真开始时气室内气体的绝对温度。",
-        ),
-        ParameterDefinition("vol1", 0.0, label="端口 1 外部容积", quantity="volume", unit="m3"),
-        ParameterDefinition("vol2", 0.0, label="端口 2 外部容积", quantity="volume", unit="m3"),
-        ParameterDefinition("vol3", 0.0, label="端口 3 外部容积", quantity="volume", unit="m3"),
-        ParameterDefinition("vol4", 0.0, label="端口 4 外部容积", quantity="volume", unit="m3"),
-        ParameterDefinition("dvol1", 0.0, label="端口 1 容积变化率", quantity="volume_flow", unit="m3/s"),
-        ParameterDefinition("dvol2", 0.0, label="端口 2 容积变化率", quantity="volume_flow", unit="m3/s"),
-        ParameterDefinition("dvol3", 0.0, label="端口 3 容积变化率", quantity="volume_flow", unit="m3/s"),
-        ParameterDefinition("dvol4", 0.0, label="端口 4 容积变化率", quantity="volume_flow", unit="m3/s"),
-    )
-    RESULT_VARIABLES = THERMODYNAMIC_VOLUME_RESULT_VARIABLES + (
-        ResultVariableDefinition("vol", "气室总容积", "volume", "m3", "derived", 100),
-        ResultVariableDefinition("dvol", "总容积变化率", "volume_flow", "m3/s", "derived", 110),
-    )
-    DISPLAY = ComponentDisplaySpec(
-        label="PNCH012 变容气室",
-        library_id="amesim",
-        category_id="storage",
-        symbol="amesim_pnch012",
-        ports=(
-            PortDisplaySpec("port_1", "left", order=10),
-            PortDisplaySpec("port_2", "right", order=20),
-            PortDisplaySpec("port_3", "left", order=30),
-            PortDisplaySpec("port_4", "right", order=40),
-        ),
-        order=20,
-    )
-
-    def __init__(
-        self,
-        name: str,
-        medium: GasMedium,
-        *,
-        cvol0: float = 0.015,
-        kth: float = 0.0,
-        sth: float = 0.1,
-        extemp: float = 293.15,
-        gi: float = 1.0,
-        p0: float = 100000.0,
-        T0: float = 293.15,
-        vol1: float = 0.0,
-        vol2: float = 0.0,
-        vol3: float = 0.0,
-        vol4: float = 0.0,
-        dvol1: float = 0.0,
-        dvol2: float = 0.0,
-        dvol3: float = 0.0,
-        dvol4: float = 0.0,
-    ) -> None:
+    def __init__(self, name: str, medium: GasMedium, *, cvol0: float=0.015, kth: float=0.0, sth: float=0.1, extemp: float=293.15, gi: float=1.0, p0: float=100000.0, T0: float=293.15, vol1: float=0.0, vol2: float=0.0, vol3: float=0.0, vol4: float=0.0, dvol1: float=0.0, dvol2: float=0.0, dvol3: float=0.0, dvol4: float=0.0) -> None:
         super().__init__(name=name)
-        self.set_parameter_values(
-            {
-                "cvol0": cvol0,
-                "kth": kth,
-                "sth": sth,
-                "extemp": extemp,
-                "gi": gi,
-                "p0": p0,
-                "T0": T0,
-                "vol1": vol1,
-                "vol2": vol2,
-                "vol3": vol3,
-                "vol4": vol4,
-                "dvol1": dvol1,
-                "dvol2": dvol2,
-                "dvol3": dvol3,
-                "dvol4": dvol4,
-            }
-        )
+        self.set_parameter_values({'cvol0': cvol0, 'kth': kth, 'sth': sth, 'extemp': extemp, 'gi': gi, 'p0': p0, 'T0': T0, 'vol1': vol1, 'vol2': vol2, 'vol3': vol3, 'vol4': vol4, 'dvol1': dvol1, 'dvol2': dvol2, 'dvol3': dvol3, 'dvol4': dvol4})
         self.medium = medium
         self.cvol0 = float(cvol0)
         self.kth = float(kth)
@@ -424,267 +68,13 @@ class AmesimPnch012(ThermodynamicVolumeComponent):
         self.gi = normalize_amesim_gas_index(gi)
         self.p0 = float(p0)
         self.T0 = float(T0)
-        self.external_volumes = {
-            "port_1": float(vol1),
-            "port_2": float(vol2),
-            "port_3": float(vol3),
-            "port_4": float(vol4),
-        }
-        self.external_volume_rates = {
-            "port_1": float(dvol1),
-            "port_2": float(dvol2),
-            "port_3": float(dvol3),
-            "port_4": float(dvol4),
-        }
-        if self.total_volume() <= 0.0:
-            raise ValueError("PNCH012 total volume must be positive.")
-        m0 = medium.density(self.p0, self.T0) * self.total_volume()
-        U0 = m0 * medium.specific_internal_energy_at_pressure(self.p0, self.T0)
-        self.state = VolumeState(m=m0, U=U0)
-        initial_h = medium.specific_enthalpy_at_pressure(self.p0, self.T0)
-        for port_name in ("port_1", "port_2", "port_3", "port_4"):
+        self.external_volumes = {'port_1': float(vol1), 'port_2': float(vol2), 'port_3': float(vol3), 'port_4': float(vol4)}
+        self.external_volume_rates = {'port_1': float(dvol1), 'port_2': float(dvol2), 'port_3': float(dvol3), 'port_4': float(dvol4)}
+        for port_name in ('port_1', 'port_2', 'port_3', 'port_4'):
             port = self.register_declared_port(port_name)
-            port.p = self.p0
-            port.h_outflow = initial_h
             setattr(self, port_name, port)
 
     @classmethod
-    def create(
-        cls,
-        *,
-        name: str,
-        medium: GasMedium,
-        parameters: Mapping[str, float],
-    ) -> "AmesimPnch012":
+    def create(cls, *, name: str, medium: GasMedium, parameters: Mapping[str, float]) -> 'AmesimPnch012':
         return cls(name=name, medium=medium, **dict(parameters))
-
-    def connected_external_volume(self) -> float:
-        return sum(
-            getattr(getattr(self, port_name, None), "volume", 0.0)
-            for port_name in self.external_volumes
-        )
-
-    def connected_external_volume_rate(self) -> float:
-        return sum(
-            getattr(getattr(self, port_name, None), "volume_flow", 0.0)
-            for port_name in self.external_volume_rates
-        )
-
-    def total_volume(self) -> float:
-        minimum_volume = self.cvol0 / 100.0
-        return max(
-            self.cvol0 + sum(self.external_volumes.values()) + self.connected_external_volume(),
-            minimum_volume,
-        )
-
-    def total_volume_rate(self) -> float:
-        if self.total_volume() <= self.cvol0 / 100.0:
-            return 0.0
-        return sum(self.external_volume_rates.values()) + self.connected_external_volume_rate()
-
-    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 properties(self) -> ThermodynamicProperties:
-        props = self.medium.properties_from_mU(self.state.m, self.state.U, self.total_volume())
-        for port_name in ("port_1", "port_2", "port_3", "port_4"):
-            port = self.get_port(port_name)
-            port.p = props.p
-            port.h_outflow = props.h
-        return props
-
-    def refresh_thermodynamic_ports(self) -> ThermodynamicProperties:
-        return self.properties()
-
-    def thermal_energy_flow_w(self, temperature: float) -> float:
-        return self.kth * self.sth * (self.extemp - temperature)
-
-    def component_result_values(self) -> Mapping[str, float]:
-        props = self.properties()
-        return {
-            "m": self.state.m,
-            "U": self.state.U,
-            "p": props.p,
-            "T": props.T,
-            "rho": props.rho,
-            "u": props.u,
-            "h": props.h,
-            "vol": self.total_volume(),
-            "dvol": self.total_volume_rate(),
-        }
-
-    def state_derivative_from_ports(self, connected_h: Mapping[str, float]) -> list[float]:
-        props = self.properties()
-        mass_derivative = 0.0
-        energy_derivative = 0.0
-        for port_name in ("port_1", "port_2", "port_3", "port_4"):
-            port = self.get_port(port_name)
-            inlet_h = self.connection_inlet_enthalpy(
-                port_m_flow=port.m_flow,
-                connected_h=connected_h[port_name],
-                internal_h=props.h,
-            )
-            mass_derivative += port.m_flow
-            energy_derivative += port.m_flow * inlet_h
-        energy_derivative += self.thermal_energy_flow_w(props.T)
-        energy_derivative -= props.p * self.total_volume_rate()
-        return VolumeState(m=mass_derivative, U=energy_derivative).as_vector()
-
-    def linearize_state_derivative(
-        self,
-        connected_h: Mapping[str, float],
-        *,
-        state_mass_tangent: Sequence[float],
-        state_energy_tangent: Sequence[float],
-        external_volume_tangent: Sequence[float],
-        external_volume_rate_tangent: Sequence[float],
-        port_mass_flow_tangents: Mapping[str, Sequence[float]],
-        connected_h_tangents: Mapping[str, Sequence[float]],
-        property_linearization: ThermodynamicPropertiesLinearization | None = None,
-        flow_boundary_tolerance: float = 1.0e-12,
-    ) -> Pnch012DerivativeLinearization:
-        """Linearize the chamber balance while keeping stream modes fixed."""
-
-        port_names = ("port_1", "port_2", "port_3", "port_4")
-        vectors = {
-            "state_mass": tuple(float(value) for value in state_mass_tangent),
-            "state_energy": tuple(float(value) for value in state_energy_tangent),
-            "volume": tuple(float(value) for value in external_volume_tangent),
-            "volume_rate": tuple(
-                float(value) for value in external_volume_rate_tangent
-            ),
-        }
-        for port_name in port_names:
-            vectors[f"flow:{port_name}"] = tuple(
-                float(value) for value in port_mass_flow_tangents[port_name]
-            )
-            vectors[f"enthalpy:{port_name}"] = tuple(
-                float(value) for value in connected_h_tangents[port_name]
-            )
-        widths = {len(values) for values in vectors.values()}
-        if len(widths) != 1:
-            raise ValueError("PNCH012 tangent vectors must have equal lengths.")
-        width = len(vectors["state_mass"])
-        invalid_reason: str | None = None
-        if not all(isfinite(value) for values in vectors.values() for value in values):
-            invalid_reason = "non_finite_tangent_input"
-
-        raw_volume = (
-            self.cvol0
-            + sum(self.external_volumes.values())
-            + self.connected_external_volume()
-        )
-        minimum_volume = self.cvol0 / 100.0
-        volume_scale = max(abs(raw_volume), abs(minimum_volume), 1.0e-18)
-        on_volume_boundary = (
-            abs(raw_volume - minimum_volume) <= 1.0e-12 * volume_scale
-        )
-        supplied_volume_tangent = vectors["volume"]
-        if raw_volume < minimum_volume or on_volume_boundary:
-            used_volume_tangent = (0.0,) * width
-            used_volume_rate_tangent = (0.0,) * width
-            if on_volume_boundary and any(
-                value != 0.0
-                for value in (
-                    *supplied_volume_tangent,
-                    *vectors["volume_rate"],
-                )
-            ):
-                invalid_reason = invalid_reason or "volume_floor_boundary"
-        else:
-            used_volume_tangent = supplied_volume_tangent
-            used_volume_rate_tangent = vectors["volume_rate"]
-
-        properties = property_linearization or self.medium.linearize_properties_from_mU(
-            self.state.m,
-            self.state.U,
-            self.total_volume(),
-            vectors["state_mass"],
-            vectors["state_energy"],
-            used_volume_tangent,
-        )
-        if properties.tangents.width != width:
-            raise ValueError(
-                "PNCH012 property tangent width must match balance tangents."
-            )
-        props = properties.properties
-        if not properties.valid:
-            invalid_reason = invalid_reason or properties.reason
-
-        mass_derivative = sum(
-            self.get_port(port_name).m_flow for port_name in port_names
-        )
-        volume_rate = self.total_volume_rate()
-        energy_derivative = self.thermal_energy_flow_w(props.T) - props.p * volume_rate
-        mass_tangent = [0.0] * width
-        energy_tangent = [
-            -self.kth * self.sth * properties.tangents.T[index]
-            - volume_rate * properties.tangents.p[index]
-            - props.p * used_volume_rate_tangent[index]
-            for index in range(width)
-        ]
-
-        for port_name in port_names:
-            port = self.get_port(port_name)
-            flow_tangent = vectors[f"flow:{port_name}"]
-            if (
-                abs(port.m_flow) <= flow_boundary_tolerance
-                and any(value != 0.0 for value in flow_tangent)
-            ):
-                invalid_reason = invalid_reason or (
-                    f"flow_direction_boundary:{port_name}"
-                )
-            if port.m_flow > 0.0:
-                inlet_h = connected_h[port_name]
-                inlet_h_tangent = vectors[f"enthalpy:{port_name}"]
-            else:
-                inlet_h = props.h
-                inlet_h_tangent = properties.tangents.h
-            energy_derivative += port.m_flow * inlet_h
-            for index in range(width):
-                mass_tangent[index] += flow_tangent[index]
-                energy_tangent[index] += (
-                    inlet_h * flow_tangent[index]
-                    + port.m_flow * inlet_h_tangent[index]
-                )
-
-        return Pnch012DerivativeLinearization(
-            derivative=(mass_derivative, energy_derivative),
-            tangents=(tuple(mass_tangent), tuple(energy_tangent)),
-            properties=properties,
-            valid=invalid_reason is None,
-            reason=invalid_reason,
-        )
-
-    def pressure_flow_equation_values(self) -> tuple[float, ...]:
-        pressure = self.medium.properties_from_mU(
-            self.state.m,
-            self.state.U,
-            self.total_volume(),
-        ).p
-        return tuple(
-            self.get_port(port_name).p - pressure
-            for port_name in ("port_1", "port_2", "port_3", "port_4")
-        )
-
-    def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
-        pressure = self.medium.properties_from_mU(
-            self.state.m,
-            self.state.U,
-            self.total_volume(),
-        ).p
-        return tuple(
-            EquationResidual(
-                id=f"{self.name}:{port_name}_pressure_state",
-                owner="component",
-                owner_id=self.name,
-                relation="state",
-                variables=(f"{self.name}.{port_name}.p", f"{self.name}.state"),
-                role="effort",
-                value=self.get_port(port_name).p - pressure,
-            )
-            for port_name in ("port_1", "port_2", "port_3", "port_4")
-        )
+    EQUATIONS = ({'id': '__MODEL__:port_1_pressure_state', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'state', 'variables': ['__MODEL__.port_1.p', '__MODEL__.state'], 'role': 'effort'}, {'id': '__MODEL__:port_2_pressure_state', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'state', 'variables': ['__MODEL__.port_2.p', '__MODEL__.state'], 'role': 'effort'}, {'id': '__MODEL__:port_3_pressure_state', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'state', 'variables': ['__MODEL__.port_3.p', '__MODEL__.state'], 'role': 'effort'}, {'id': '__MODEL__:port_4_pressure_state', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'state', 'variables': ['__MODEL__.port_4.p', '__MODEL__.state'], 'role': 'effort'})