Replace Python numerical kernels with native C execution

app/simulation/components/experimental/flow/orifice.py

@@ -1,121 +1,34 @@
+"""Component parameters, ports and output definitions; numerical equations execute in C."""
 from __future__ import annotations
-
 from collections.abc import Mapping
-from math import sqrt
-
 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
 from app.simulation.core.medium import IdealGasMedium
 from app.simulation.core.ports import PortDefinition
 
-
 class Orifice(AlgebraicComponent):
     """Python port of ModelicaModels.Myorifice."""
-
-    MODEL_TYPE = "orifice"
-    MODEL_VERSION = "1.0.0"
-    PRESSURE_FLOW_DEPENDS_ON_STREAM = False
-    PRESSURE_FLOW_EXACT_SUM_TO_ZERO_EQUATION_SUFFIXES = frozenset(
-        ("mass_flow_balance",)
-    )
-    PORTS = (
-        PortDefinition.pneumatic("port_a", nominal_role="inlet"),
-        PortDefinition.pneumatic("port_b", nominal_role="outlet"),
-    )
-    PARAMETERS = (
-        ParameterDefinition(
-            "K",
-            1e-5,
-            label="流量系数",
-            quantity="flow_coefficient",
-            unit="kg/(s*Pa^0.5)",
-            minimum=0.0,
-        ),
-        ParameterDefinition(
-            "opening",
-            1.0,
-            label="开度",
-            minimum=0.0,
-            maximum=1.0,
-        ),
-    )
+    MODEL_TYPE = 'orifice'
+    MODEL_VERSION = '1.0.0'
+    PORTS = (PortDefinition.pneumatic('port_a', nominal_role='inlet'), PortDefinition.pneumatic('port_b', nominal_role='outlet'))
+    PARAMETERS = (ParameterDefinition('K', 1e-05, label='流量系数', quantity='flow_coefficient', unit='kg/(s*Pa^0.5)', minimum=0.0), ParameterDefinition('opening', 1.0, label='开度', minimum=0.0, maximum=1.0))
     RESULT_VARIABLES = ()
-    DISPLAY = ComponentDisplaySpec(
-        label="孔板/阀门",
-        library_id="experimental",
-        category_id="flow",
-        symbol="orifice",
-        ports=(
-            PortDisplaySpec("port_a", "left", order=10),
-            PortDisplaySpec("port_b", "right", order=20),
-        ),
-        order=40,
-    )
+    DISPLAY = ComponentDisplaySpec(label='孔板/阀门', library_id='experimental', category_id='flow', symbol='orifice', ports=(PortDisplaySpec('port_a', 'left', order=10), PortDisplaySpec('port_b', 'right', order=20)), order=40)
 
-    def __init__(self, name: str, opening: float = 1.0, K: float = 1e-5) -> None:
+    def __init__(self, name: str, opening: float=1.0, K: float=1e-05) -> None:
         super().__init__(name=name)
-        self.set_parameter_values({"K": K, "opening": opening})
+        self.set_parameter_values({'K': K, 'opening': opening})
         self.opening = opening
         self.K = K
-        self.port_a = self.register_declared_port("port_a")
-        self.port_b = self.register_declared_port("port_b")
+        self.port_a = self.register_declared_port('port_a')
+        self.port_b = self.register_declared_port('port_b')
 
     @classmethod
-    def create(
-        cls,
-        *,
-        name: str,
-        medium: IdealGasMedium,
-        parameters: Mapping[str, float],
-    ) -> Orifice:
-        return cls(
-            name=name,
-            opening=parameters["opening"],
-            K=parameters["K"],
-        )
+    def create(cls, *, name: str, medium: IdealGasMedium, parameters: Mapping[str, float]) -> Orifice:
+        return cls(name=name, opening=parameters['opening'], K=parameters['K'])
 
     @property
     def K_eff(self) -> float:
         return self.K * max(self.opening, 0.001)
-
-    def mass_flow(self, p_a: float, p_b: float) -> float:
-        dp = p_a - p_b
-        if dp == 0.0:
-            return 0.0
-        return self.K_eff * sqrt(abs(dp)) * (1.0 if dp > 0.0 else -1.0)
-
-    def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
-        return (
-            EquationResidual(
-                id=f"{self.name}:mass_flow_balance",
-                owner="component",
-                owner_id=self.name,
-                relation="sumToZero",
-                variables=(
-                    f"{self.name}.port_a.m_flow",
-                    f"{self.name}.port_b.m_flow",
-                ),
-                role="flow",
-                value=self.port_a.m_flow + self.port_b.m_flow,
-            ),
-            EquationResidual(
-                id=f"{self.name}:pressure_flow_relation",
-                owner="component",
-                owner_id=self.name,
-                relation="constitutive",
-                variables=(
-                    f"{self.name}.port_a.p",
-                    f"{self.name}.port_b.p",
-                    f"{self.name}.port_a.m_flow",
-                ),
-                role="flow",
-                value=self.port_a.m_flow
-                - self.mass_flow(self.port_a.p, self.port_b.p),
-            ),
-        )
-
-    def update_stream_outflows(self, connected_h: Mapping[str, float]) -> None:
-        self.port_a.h_outflow = connected_h["port_b"]
-        self.port_b.h_outflow = connected_h["port_a"]
+    EQUATIONS = ({'id': '__MODEL__:mass_flow_balance', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'sumToZero', 'variables': ['__MODEL__.port_a.m_flow', '__MODEL__.port_b.m_flow'], 'role': 'flow'}, {'id': '__MODEL__:pressure_flow_relation', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'constitutive', 'variables': ['__MODEL__.port_a.p', '__MODEL__.port_b.p', '__MODEL__.port_a.m_flow'], 'role': 'flow'})

app/simulation/components/experimental/flow/pipe.py

@@ -1,10 +0,0 @@
-"""Compatibility import for the TestModel-only dynamic pipe.
-
-The public ``pipe`` catalog model is ``ResistivePipe``. New code should import
-this legacy dynamic model from ``app.simulation.examples.testmodel.dynamic_pipe``.
-"""
-
-from app.simulation.examples.testmodel.dynamic_pipe import Pipe
-
-
-__all__ = ("Pipe",)

app/simulation/components/experimental/flow/resistive_pipe.py

@@ -1,106 +1,25 @@
+"""Component parameters, ports and output definitions; numerical equations execute in C."""
 from __future__ import annotations
-
 from collections.abc import Mapping
 from math import pi
-
 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
 from app.simulation.core.medium import IdealGasMedium
 from app.simulation.core.ports import PortDefinition
 
-
 class ResistivePipe(AlgebraicComponent):
     """Quasi-steady Darcy resistance used by topology-driven simulation."""
-
-    MODEL_TYPE = "pipe"
-    MODEL_VERSION = "1.0.0"
-    PRESSURE_FLOW_DEPENDS_ON_STREAM = False
-    PRESSURE_FLOW_EXACT_SUM_TO_ZERO_EQUATION_SUFFIXES = frozenset(
-        ("mass_flow_balance",)
-    )
-    PORTS = (
-        PortDefinition.pneumatic("port_a", nominal_role="inlet"),
-        PortDefinition.pneumatic("port_b", nominal_role="outlet"),
-    )
-    PARAMETERS = (
-        ParameterDefinition(
-            "length",
-            5.0,
-            label="长度",
-            quantity="length",
-            unit="m",
-            minimum=0.0,
-            minimum_exclusive=True,
-        ),
-        ParameterDefinition(
-            "diameter",
-            0.02,
-            label="直径",
-            quantity="length",
-            unit="m",
-            minimum=0.0,
-            minimum_exclusive=True,
-        ),
-        ParameterDefinition(
-            "lambda_darcy",
-            0.02,
-            label="摩阻系数",
-            minimum=0.0,
-        ),
-        ParameterDefinition(
-            "p0",
-            1e5,
-            label="初始压力",
-            quantity="pressure",
-            unit="Pa",
-            minimum=0.0,
-            minimum_exclusive=True,
-        ),
-        ParameterDefinition(
-            "T0",
-            300.0,
-            label="初始温度",
-            quantity="temperature",
-            unit="K",
-            minimum=0.0,
-            minimum_exclusive=True,
-        ),
-    )
+    MODEL_TYPE = 'pipe'
+    MODEL_VERSION = '1.0.0'
+    PORTS = (PortDefinition.pneumatic('port_a', nominal_role='inlet'), PortDefinition.pneumatic('port_b', nominal_role='outlet'))
+    PARAMETERS = (ParameterDefinition('length', 5.0, label='长度', quantity='length', unit='m', minimum=0.0, minimum_exclusive=True), ParameterDefinition('diameter', 0.02, label='直径', quantity='length', unit='m', minimum=0.0, minimum_exclusive=True), ParameterDefinition('lambda_darcy', 0.02, label='摩阻系数', minimum=0.0), ParameterDefinition('p0', 100000.0, label='初始压力', quantity='pressure', unit='Pa', minimum=0.0, minimum_exclusive=True), ParameterDefinition('T0', 300.0, label='初始温度', quantity='temperature', unit='K', minimum=0.0, minimum_exclusive=True))
     RESULT_VARIABLES = ()
-    DISPLAY = ComponentDisplaySpec(
-        label="管段",
-        library_id="experimental",
-        category_id="flow",
-        symbol="pipe",
-        ports=(
-            PortDisplaySpec("port_a", "left", order=10),
-            PortDisplaySpec("port_b", "right", order=20),
-        ),
-        order=30,
-    )
+    DISPLAY = ComponentDisplaySpec(label='管段', library_id='experimental', category_id='flow', symbol='pipe', ports=(PortDisplaySpec('port_a', 'left', order=10), PortDisplaySpec('port_b', 'right', order=20)), order=30)
 
-    def __init__(
-        self,
-        name: str,
-        medium: IdealGasMedium,
-        L: float = 5.0,
-        D: float = 0.02,
-        lambda_darcy: float = 0.02,
-        p0: float = 1e5,
-        T0: float = 300.0,
-    ) -> None:
+    def __init__(self, name: str, medium: IdealGasMedium, L: float=5.0, D: float=0.02, lambda_darcy: float=0.02, p0: float=100000.0, T0: float=300.0) -> None:
         super().__init__(name=name)
-        self.set_parameter_values(
-            {
-                "length": L,
-                "diameter": D,
-                "lambda_darcy": lambda_darcy,
-                "p0": p0,
-                "T0": T0,
-            }
-        )
+        self.set_parameter_values({'length': L, 'diameter': D, 'lambda_darcy': lambda_darcy, 'p0': p0, 'T0': T0})
         self.medium = medium
         self.L = L
         self.D = D
@@ -108,82 +27,10 @@ class ResistivePipe(AlgebraicComponent):
         self.p0 = p0
         self.T0 = T0
         self.area = pi * D * D / 4.0
-        initial_h = medium.specific_enthalpy(T0)
-
-        self.port_a = self.register_declared_port("port_a")
-        self.port_a.p = p0
-        self.port_a.h_outflow = initial_h
-
-        self.port_b = self.register_declared_port("port_b")
-        self.port_b.p = p0
-        self.port_b.h_outflow = initial_h
+        self.port_a = self.register_declared_port('port_a')
+        self.port_b = self.register_declared_port('port_b')
 
     @classmethod
-    def create(
-        cls,
-        *,
-        name: str,
-        medium: IdealGasMedium,
-        parameters: Mapping[str, float],
-    ) -> ResistivePipe:
-        return cls(
-            name=name,
-            medium=medium,
-            L=parameters["length"],
-            D=parameters["diameter"],
-            lambda_darcy=parameters["lambda_darcy"],
-            p0=parameters["p0"],
-            T0=parameters["T0"],
-        )
-
-    def pressure_drop(self, m_flow_a: float, p_a: float, p_b: float) -> float:
-        average_pressure = max(0.5 * (p_a + p_b), 1.0)
-        density = max(self.medium.density(average_pressure, self.T0), 1e-12)
-        resistance = self.lambda_darcy * (self.L / self.D)
-        return (
-            resistance
-            * m_flow_a
-            * abs(m_flow_a)
-            / (2.0 * density * self.area * self.area)
-        )
-
-    def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
-        return (
-            EquationResidual(
-                id=f"{self.name}:mass_flow_balance",
-                owner="component",
-                owner_id=self.name,
-                relation="sumToZero",
-                variables=(
-                    f"{self.name}.port_a.m_flow",
-                    f"{self.name}.port_b.m_flow",
-                ),
-                role="flow",
-                value=self.port_a.m_flow + self.port_b.m_flow,
-            ),
-            EquationResidual(
-                id=f"{self.name}:darcy_pressure_loss",
-                owner="component",
-                owner_id=self.name,
-                relation="constitutive",
-                variables=(
-                    f"{self.name}.port_a.p",
-                    f"{self.name}.port_b.p",
-                    f"{self.name}.port_a.m_flow",
-                ),
-                role="effort",
-                value=(
-                    self.port_a.p
-                    - self.port_b.p
-                    - self.pressure_drop(
-                        self.port_a.m_flow,
-                        self.port_a.p,
-                        self.port_b.p,
-                    )
-                ),
-            ),
-        )
-
-    def update_stream_outflows(self, connected_h: Mapping[str, float]) -> None:
-        self.port_a.h_outflow = connected_h["port_b"]
-        self.port_b.h_outflow = connected_h["port_a"]
+    def create(cls, *, name: str, medium: IdealGasMedium, parameters: Mapping[str, float]) -> ResistivePipe:
+        return cls(name=name, medium=medium, L=parameters['length'], D=parameters['diameter'], lambda_darcy=parameters['lambda_darcy'], p0=parameters['p0'], T0=parameters['T0'])
+    EQUATIONS = ({'id': '__MODEL__:mass_flow_balance', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'sumToZero', 'variables': ['__MODEL__.port_a.m_flow', '__MODEL__.port_b.m_flow'], 'role': 'flow'}, {'id': '__MODEL__:darcy_pressure_loss', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'constitutive', 'variables': ['__MODEL__.port_a.p', '__MODEL__.port_b.p', '__MODEL__.port_a.m_flow'], 'role': 'effort'})

app/simulation/components/experimental/junctions/tee.py

@@ -1,270 +1,28 @@
+"""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 Tee(AlgebraicComponent):
     """Python port of ModelicaModels.Mytee."""
-
-    MODEL_TYPE = "tee"
-    MODEL_VERSION = "1.0.0"
-    PRESSURE_FLOW_DEPENDS_ON_STREAM = False
-    PRESSURE_FLOW_EXACT_SUM_TO_ZERO_EQUATION_SUFFIXES = frozenset(
-        ("mass_flow_balance",)
-    )
-    PORTS = (
-        PortDefinition.pneumatic("port_in", nominal_role="bidirectional"),
-        PortDefinition.pneumatic("port_out1", nominal_role="bidirectional"),
-        PortDefinition.pneumatic("port_out2", nominal_role="bidirectional"),
-    )
+    MODEL_TYPE = 'tee'
+    MODEL_VERSION = '1.0.0'
+    PORTS = (PortDefinition.pneumatic('port_in', nominal_role='bidirectional'), PortDefinition.pneumatic('port_out1', nominal_role='bidirectional'), PortDefinition.pneumatic('port_out2', nominal_role='bidirectional'))
     PARAMETERS = ()
     RESULT_VARIABLES = ()
-    DISPLAY = ComponentDisplaySpec(
-        label="三通",
-        library_id="experimental",
-        category_id="junctions",
-        symbol="tee",
-        ports=(
-            PortDisplaySpec("port_in", "left", order=10),
-            PortDisplaySpec("port_out1", "right", order=20),
-            PortDisplaySpec("port_out2", "right", order=30),
-        ),
-        order=50,
-    )
+    DISPLAY = ComponentDisplaySpec(label='三通', library_id='experimental', category_id='junctions', symbol='tee', ports=(PortDisplaySpec('port_in', 'left', order=10), PortDisplaySpec('port_out1', 'right', order=20), PortDisplaySpec('port_out2', 'right', order=30)), order=50)
 
     def __init__(self, name: str) -> None:
         super().__init__(name=name)
         self.set_parameter_values({})
-        self.port_in = self.register_declared_port("port_in")
-        self.port_out1 = self.register_declared_port("port_out1")
-        self.port_out2 = self.register_declared_port("port_out2")
+        self.port_in = self.register_declared_port('port_in')
+        self.port_out1 = self.register_declared_port('port_out1')
+        self.port_out2 = self.register_declared_port('port_out2')
 
     @classmethod
-    def create(
-        cls,
-        *,
-        name: str,
-        medium: IdealGasMedium,
-        parameters: Mapping[str, float],
-    ) -> Tee:
+    def create(cls, *, name: str, medium: IdealGasMedium, parameters: Mapping[str, float]) -> Tee:
         return cls(name=name)
-
-    def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
-        return (
-            EquationResidual(
-                id=f"{self.name}:common_pressure_out1",
-                owner="component",
-                owner_id=self.name,
-                relation="equal",
-                variables=(f"{self.name}.port_in.p", f"{self.name}.port_out1.p"),
-                role="effort",
-                value=self.port_in.p - self.port_out1.p,
-            ),
-            EquationResidual(
-                id=f"{self.name}:common_pressure_out2",
-                owner="component",
-                owner_id=self.name,
-                relation="equal",
-                variables=(f"{self.name}.port_in.p", f"{self.name}.port_out2.p"),
-                role="effort",
-                value=self.port_in.p - self.port_out2.p,
-            ),
-            EquationResidual(
-                id=f"{self.name}:mass_flow_balance",
-                owner="component",
-                owner_id=self.name,
-                relation="sumToZero",
-                variables=(
-                    f"{self.name}.port_in.m_flow",
-                    f"{self.name}.port_out1.m_flow",
-                    f"{self.name}.port_out2.m_flow",
-                ),
-                role="flow",
-                value=(
-                    self.port_in.m_flow
-                    + self.port_out1.m_flow
-                    + self.port_out2.m_flow
-                ),
-            ),
-        )
-
-    def update_stream_outflows(self, connected_h: Mapping[str, float]) -> None:
-        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 * enthalpy for m_flow, enthalpy in incoming
-            ) / total_flow
-        else:
-            values = list(connected_h.values())
-            mixed_h = sum(values) / len(values) if values else 0.0
-        for port in self.ports.values():
-            port.h_outflow = mixed_h
-
-    def mixed_inlet_enthalpy(
-        self,
-        branch1_m_flow: float,
-        branch1_h: float,
-        branch2_m_flow: float,
-        branch2_h: float,
-        fallback_h: float = 0.0,
-    ) -> float:
-        positive_1 = max(branch1_m_flow, 0.0)
-        positive_2 = max(branch2_m_flow, 0.0)
-        total = positive_1 + positive_2
-        if total <= 1e-9:
-            return fallback_h
-        return (positive_1 * branch1_h + positive_2 * branch2_h) / total
-
-    def inlet_stream_enthalpy(
-        self,
-        branch1_m_flow: float,
-        branch1_h: float,
-        branch2_m_flow: float,
-        branch2_h: float,
-        fallback_h: float,
-    ) -> float:
-        """Approximate `inStream(port_in.h_outflow)` for the current tee topology."""
-
-        return self.mixed_inlet_enthalpy(
-            branch1_m_flow,
-            branch1_h,
-            branch2_m_flow,
-            branch2_h,
-            fallback_h=fallback_h,
-        )
-
-    def branch_actual_stream_enthalpy(
-        self,
-        branch_m_flow: float,
-        branch_h: float,
-        inlet_h: float,
-    ) -> float:
-        """Approximate `actualStream(branch.h_outflow)` for a tee branch port."""
-
-        return inlet_h if branch_m_flow > 0.0 else branch_h
-
-    @staticmethod
-    def _solve_linear_2x2(
-        a11: float,
-        a12: float,
-        a21: float,
-        a22: float,
-        b1: float,
-        b2: float,
-    ) -> tuple[float, float] | None:
-        determinant = a11 * a22 - a12 * a21
-        if abs(determinant) <= 1e-12:
-            return None
-        x1 = (b1 * a22 - b2 * a12) / determinant
-        x2 = (a11 * b2 - a21 * b1) / determinant
-        return x1, x2
-
-    def solve_branch_outlet_flows_from_energy_balance(
-        self,
-        *,
-        ratio_branch1: float,
-        ratio_branch2: float,
-        inlet_h_branch1: float,
-        inlet_h_branch2: float,
-        branch1_h: float,
-        branch2_h: float,
-        inlet_h: float,
-        q_in_branch1: float,
-        q_in_branch2: float,
-        tolerance: float = 1e-12,
-    ) -> tuple[float, float]:
-        """Solve branch outlet flows for the current three-port downstream tee use-case."""
-
-        rhs_branch1 = q_in_branch1 * inlet_h_branch1
-        rhs_branch2 = q_in_branch2 * inlet_h_branch2
-
-        def solve_both_forward() -> tuple[float, float] | None:
-            return self._solve_linear_2x2(
-                (1.0 + ratio_branch1) * branch1_h,
-                ratio_branch1 * branch2_h,
-                ratio_branch2 * branch1_h,
-                (1.0 + ratio_branch2) * branch2_h,
-                rhs_branch1,
-                rhs_branch2,
-            )
-
-        def solve_one_reverse(
-            *,
-            branch1_reverse: bool,
-        ) -> tuple[float, float] | None:
-            if branch1_reverse:
-                return self._solve_linear_2x2(
-                    inlet_h * (1.0 + ratio_branch1),
-                    ratio_branch1 * inlet_h,
-                    ratio_branch2 * inlet_h,
-                    branch2_h + ratio_branch2 * inlet_h,
-                    rhs_branch1,
-                    rhs_branch2,
-                )
-
-            return self._solve_linear_2x2(
-                branch1_h + ratio_branch1 * inlet_h,
-                ratio_branch1 * inlet_h,
-                ratio_branch2 * inlet_h,
-                inlet_h * (1.0 + ratio_branch2),
-                rhs_branch1,
-                rhs_branch2,
-            )
-
-        def solve_both_reverse() -> tuple[float, float] | None:
-            return self._solve_linear_2x2(
-                inlet_h * (1.0 + ratio_branch1),
-                ratio_branch1 * inlet_h,
-                ratio_branch2 * inlet_h,
-                inlet_h * (1.0 + ratio_branch2),
-                rhs_branch1,
-                rhs_branch2,
-            )
-
-        candidate_solvers = (
-            (
-                solve_both_forward,
-                lambda q1, q2: q1 >= -tolerance and q2 >= -tolerance,
-            ),
-            (
-                lambda: solve_one_reverse(branch1_reverse=True),
-                lambda q1, q2: q1 < -tolerance and q2 >= -tolerance and q1 + q2 > tolerance,
-            ),
-            (
-                lambda: solve_one_reverse(branch1_reverse=True),
-                lambda q1, q2: q1 < -tolerance and q2 >= -tolerance and q1 + q2 <= tolerance,
-            ),
-            (
-                lambda: solve_one_reverse(branch1_reverse=False),
-                lambda q1, q2: q2 < -tolerance and q1 >= -tolerance and q1 + q2 > tolerance,
-            ),
-            (
-                lambda: solve_one_reverse(branch1_reverse=False),
-                lambda q1, q2: q2 < -tolerance and q1 >= -tolerance and q1 + q2 <= tolerance,
-            ),
-            (
-                solve_both_reverse,
-                lambda q1, q2: q1 < -tolerance and q2 < -tolerance,
-            ),
-        )
-
-        for solver, predicate in candidate_solvers:
-            candidate = solver()
-            if candidate is None:
-                continue
-            q_out_branch1, q_out_branch2 = candidate
-            if predicate(q_out_branch1, q_out_branch2):
-                return q_out_branch1, q_out_branch2
-
-        return solve_both_forward() or (0.0, 0.0)
+    EQUATIONS = ({'id': '__MODEL__:common_pressure_out1', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'equal', 'variables': ['__MODEL__.port_in.p', '__MODEL__.port_out1.p'], 'role': 'effort'}, {'id': '__MODEL__:common_pressure_out2', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'equal', 'variables': ['__MODEL__.port_in.p', '__MODEL__.port_out2.p'], 'role': 'effort'}, {'id': '__MODEL__:mass_flow_balance', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'sumToZero', 'variables': ['__MODEL__.port_in.m_flow', '__MODEL__.port_out1.m_flow', '__MODEL__.port_out2.m_flow'], 'role': 'flow'})

app/simulation/components/experimental/storage/cylinder.py

@@ -1,155 +1,29 @@
+"""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 ThermodynamicVolumeComponent
 from app.simulation.core.catalog import ComponentDisplaySpec, PortDisplaySpec
-from app.simulation.core.equations import EquationResidual
-from app.simulation.core.metadata import (
-    ParameterDefinition,
-    THERMODYNAMIC_VOLUME_RESULT_VARIABLES,
-)
-from app.simulation.core.medium import IdealGasMedium, ThermodynamicProperties
+from app.simulation.core.metadata import ParameterDefinition, THERMODYNAMIC_VOLUME_RESULT_VARIABLES
+from app.simulation.core.medium import IdealGasMedium
 from app.simulation.core.ports import PortDefinition
-from app.simulation.core.state import VolumeState
-
 
 class Cylinder(ThermodynamicVolumeComponent):
     """Python port of ModelicaModels.Mycylinder."""
-
-    MODEL_TYPE = "cylinder"
-    MODEL_VERSION = "1.0.0"
-    PORTS = (PortDefinition.pneumatic("port_b", nominal_role="outlet"),)
-    PARAMETERS = (
-        ParameterDefinition(
-            "volume",
-            0.01,
-            label="容积",
-            quantity="volume",
-            unit="m3",
-            minimum=0.0,
-            minimum_exclusive=True,
-        ),
-        ParameterDefinition(
-            "p0",
-            35e6,
-            label="初始压力",
-            quantity="pressure",
-            unit="Pa",
-            minimum=0.0,
-            minimum_exclusive=True,
-        ),
-        ParameterDefinition(
-            "T0",
-            300.0,
-            label="初始温度",
-            quantity="temperature",
-            unit="K",
-            minimum=0.0,
-            minimum_exclusive=True,
-        ),
-    )
+    MODEL_TYPE = 'cylinder'
+    MODEL_VERSION = '1.0.0'
+    PORTS = (PortDefinition.pneumatic('port_b', nominal_role='outlet'),)
+    PARAMETERS = (ParameterDefinition('volume', 0.01, label='容积', quantity='volume', unit='m3', minimum=0.0, minimum_exclusive=True), ParameterDefinition('p0', 35000000.0, label='初始压力', quantity='pressure', unit='Pa', minimum=0.0, minimum_exclusive=True), ParameterDefinition('T0', 300.0, label='初始温度', quantity='temperature', unit='K', minimum=0.0, minimum_exclusive=True))
     RESULT_VARIABLES = THERMODYNAMIC_VOLUME_RESULT_VARIABLES
-    DISPLAY = ComponentDisplaySpec(
-        label="气瓶",
-        library_id="experimental",
-        category_id="storage",
-        symbol="cylinder",
-        ports=(PortDisplaySpec("port_b", "right"),),
-        order=10,
-    )
+    DISPLAY = ComponentDisplaySpec(label='气瓶', library_id='experimental', category_id='storage', symbol='cylinder', ports=(PortDisplaySpec('port_b', 'right'),), order=10)
 
-    def __init__(
-        self,
-        name: str,
-        medium: IdealGasMedium,
-        V: float = 0.01,
-        p0: float = 35e6,
-        T0: float = 300.0,
-    ) -> None:
+    def __init__(self, name: str, medium: IdealGasMedium, V: float=0.01, p0: float=35000000.0, T0: float=300.0) -> None:
         super().__init__(name=name)
-        self.set_parameter_values({"volume": V, "p0": p0, "T0": T0})
+        self.set_parameter_values({'volume': V, 'p0': p0, 'T0': T0})
         self.medium = medium
         self.V = V
-        m0 = p0 * V / (medium.R_gas * T0)
-        U0 = m0 * medium.specific_internal_energy(T0)
-        self.state = VolumeState(m=m0, U=U0)
-        self.port_b = self.register_declared_port("port_b")
+        self.port_b = self.register_declared_port('port_b')
 
     @classmethod
-    def create(
-        cls,
-        *,
-        name: str,
-        medium: IdealGasMedium,
-        parameters: Mapping[str, float],
-    ) -> Cylinder:
-        return cls(
-            name=name,
-            medium=medium,
-            V=parameters["volume"],
-            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.V)
-        self.port_b.p = props.p
-        self.port_b.h_outflow = props.h
-        return props
-
-    def refresh_thermodynamic_ports(self) -> ThermodynamicProperties:
-        return self.properties()
-
-    def state_derivative_from_ports(
-        self,
-        connected_h: Mapping[str, float],
-    ) -> list[float]:
-        properties = self.properties()
-        derivative = self.derivatives_from_connection(
-            connected_h=connected_h["port_b"],
-            port_m_flow=self.port_b.m_flow,
-            internal_h=properties.h,
-        )
-        return derivative.as_vector()
-
-    def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
-        pressure = self.medium.properties_from_mU(
-            self.state.m,
-            self.state.U,
-            self.V,
-        ).p
-        return (
-            EquationResidual(
-                id=f"{self.name}:port_b_pressure_state",
-                owner="component",
-                owner_id=self.name,
-                relation="state",
-                variables=(f"{self.name}.port_b.p", f"{self.name}.state"),
-                role="effort",
-                value=self.port_b.p - pressure,
-            ),
-        )
-
-    def derivatives_from_connection(
-        self,
-        *,
-        connected_h: float,
-        port_m_flow: float,
-        internal_h: float,
-    ) -> VolumeState:
-        inlet_h = self.connection_inlet_enthalpy(
-            port_m_flow=port_m_flow,
-            connected_h=connected_h,
-            internal_h=internal_h,
-        )
-        return self.derivatives(inlet_h, port_m_flow)
-
-    def derivatives(self, inlet_h: float, m_flow: float) -> VolumeState:
-        return VolumeState(m=m_flow, U=m_flow * inlet_h)
+    def create(cls, *, name: str, medium: IdealGasMedium, parameters: Mapping[str, float]) -> Cylinder:
+        return cls(name=name, medium=medium, V=parameters['volume'], p0=parameters['p0'], T0=parameters['T0'])
+    EQUATIONS = ({'id': '__MODEL__:port_b_pressure_state', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'state', 'variables': ['__MODEL__.port_b.p', '__MODEL__.state'], 'role': 'effort'},)

app/simulation/components/experimental/storage/tank.py

@@ -1,155 +1,29 @@
+"""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 ThermodynamicVolumeComponent
 from app.simulation.core.catalog import ComponentDisplaySpec, PortDisplaySpec
-from app.simulation.core.equations import EquationResidual
-from app.simulation.core.metadata import (
-    ParameterDefinition,
-    THERMODYNAMIC_VOLUME_RESULT_VARIABLES,
-)
-from app.simulation.core.medium import IdealGasMedium, ThermodynamicProperties
+from app.simulation.core.metadata import ParameterDefinition, THERMODYNAMIC_VOLUME_RESULT_VARIABLES
+from app.simulation.core.medium import IdealGasMedium
 from app.simulation.core.ports import PortDefinition
-from app.simulation.core.state import VolumeState
-
 
 class Tank(ThermodynamicVolumeComponent):
     """Python port of ModelicaModels.Mytank."""
-
-    MODEL_TYPE = "tank"
-    MODEL_VERSION = "1.0.0"
-    PORTS = (PortDefinition.pneumatic("port_a", nominal_role="inlet"),)
-    PARAMETERS = (
-        ParameterDefinition(
-            "volume",
-            0.1,
-            label="容积",
-            quantity="volume",
-            unit="m3",
-            minimum=0.0,
-            minimum_exclusive=True,
-        ),
-        ParameterDefinition(
-            "p0",
-            1e5,
-            label="初始压力",
-            quantity="pressure",
-            unit="Pa",
-            minimum=0.0,
-            minimum_exclusive=True,
-        ),
-        ParameterDefinition(
-            "T0",
-            300.0,
-            label="初始温度",
-            quantity="temperature",
-            unit="K",
-            minimum=0.0,
-            minimum_exclusive=True,
-        ),
-    )
+    MODEL_TYPE = 'tank'
+    MODEL_VERSION = '1.0.0'
+    PORTS = (PortDefinition.pneumatic('port_a', nominal_role='inlet'),)
+    PARAMETERS = (ParameterDefinition('volume', 0.1, label='容积', quantity='volume', unit='m3', minimum=0.0, minimum_exclusive=True), ParameterDefinition('p0', 100000.0, label='初始压力', quantity='pressure', unit='Pa', minimum=0.0, minimum_exclusive=True), ParameterDefinition('T0', 300.0, label='初始温度', quantity='temperature', unit='K', minimum=0.0, minimum_exclusive=True))
     RESULT_VARIABLES = THERMODYNAMIC_VOLUME_RESULT_VARIABLES
-    DISPLAY = ComponentDisplaySpec(
-        label="贮箱",
-        library_id="experimental",
-        category_id="storage",
-        symbol="tank",
-        ports=(PortDisplaySpec("port_a", "left"),),
-        order=20,
-    )
+    DISPLAY = ComponentDisplaySpec(label='贮箱', library_id='experimental', category_id='storage', symbol='tank', ports=(PortDisplaySpec('port_a', 'left'),), order=20)
 
-    def __init__(
-        self,
-        name: str,
-        medium: IdealGasMedium,
-        V: float = 0.1,
-        p0: float = 1e5,
-        T0: float = 300.0,
-    ) -> None:
+    def __init__(self, name: str, medium: IdealGasMedium, V: float=0.1, p0: float=100000.0, T0: float=300.0) -> None:
         super().__init__(name=name)
-        self.set_parameter_values({"volume": V, "p0": p0, "T0": T0})
+        self.set_parameter_values({'volume': V, 'p0': p0, 'T0': T0})
         self.medium = medium
         self.V = V
-        m0 = p0 * V / (medium.R_gas * T0)
-        U0 = m0 * medium.specific_internal_energy(T0)
-        self.state = VolumeState(m=m0, U=U0)
-        self.port_a = self.register_declared_port("port_a")
+        self.port_a = self.register_declared_port('port_a')
 
     @classmethod
-    def create(
-        cls,
-        *,
-        name: str,
-        medium: IdealGasMedium,
-        parameters: Mapping[str, float],
-    ) -> Tank:
-        return cls(
-            name=name,
-            medium=medium,
-            V=parameters["volume"],
-            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.V)
-        self.port_a.p = props.p
-        self.port_a.h_outflow = props.h
-        return props
-
-    def refresh_thermodynamic_ports(self) -> ThermodynamicProperties:
-        return self.properties()
-
-    def state_derivative_from_ports(
-        self,
-        connected_h: Mapping[str, float],
-    ) -> list[float]:
-        properties = self.properties()
-        derivative = self.derivatives_from_connection(
-            connected_h=connected_h["port_a"],
-            port_m_flow=self.port_a.m_flow,
-            internal_h=properties.h,
-        )
-        return derivative.as_vector()
-
-    def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
-        pressure = self.medium.properties_from_mU(
-            self.state.m,
-            self.state.U,
-            self.V,
-        ).p
-        return (
-            EquationResidual(
-                id=f"{self.name}:port_a_pressure_state",
-                owner="component",
-                owner_id=self.name,
-                relation="state",
-                variables=(f"{self.name}.port_a.p", f"{self.name}.state"),
-                role="effort",
-                value=self.port_a.p - pressure,
-            ),
-        )
-
-    def derivatives_from_connection(
-        self,
-        *,
-        connected_h: float,
-        port_m_flow: float,
-        internal_h: float,
-    ) -> VolumeState:
-        inlet_h = self.connection_inlet_enthalpy(
-            port_m_flow=port_m_flow,
-            connected_h=connected_h,
-            internal_h=internal_h,
-        )
-        return self.derivatives(inlet_h, port_m_flow)
-
-    def derivatives(self, inlet_h: float, m_flow: float) -> VolumeState:
-        return VolumeState(m=m_flow, U=m_flow * inlet_h)
+    def create(cls, *, name: str, medium: IdealGasMedium, parameters: Mapping[str, float]) -> Tank:
+        return cls(name=name, medium=medium, V=parameters['volume'], p0=parameters['p0'], T0=parameters['T0'])
+    EQUATIONS = ({'id': '__MODEL__:port_a_pressure_state', 'owner': 'component', 'ownerId': '__MODEL__', 'relation': 'state', 'variables': ['__MODEL__.port_a.p', '__MODEL__.state'], 'role': 'effort'},)