完善 XML 通用仿真与结果查看

PythonModels/components/cylinder.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
+
 from PythonModels.core.base import DynamicComponent
+from PythonModels.core.equations import EquationResidual
 from PythonModels.core.medium import IdealGasMedium, ThermodynamicProperties
 from PythonModels.core.ports import PortState
 from PythonModels.core.state import VolumeState
@@ -23,7 +26,9 @@ class Cylinder(DynamicComponent):
         m0 = p0 * V / (medium.R_gas * T0)
         U0 = m0 * medium.specific_internal_energy(T0)
         self.state = VolumeState(m=m0, U=U0)
-        self.port_b = PortState()
+        self.port_b = self.register_port(
+            PortState.pneumatic("port_b", nominal_role="outlet")
+        )
 
     def get_state_vector(self) -> list[float]:
         return self.state.as_vector()
@@ -37,6 +42,39 @@ class Cylinder(DynamicComponent):
         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,
         *,

PythonModels/components/orifice.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
 from math import sqrt
 
 from PythonModels.core.base import AlgebraicComponent
+from PythonModels.core.equations import EquationResidual
 from PythonModels.core.ports import PortState
 
 
@@ -13,8 +15,12 @@ class Orifice(AlgebraicComponent):
         super().__init__(name=name)
         self.opening = opening
         self.K = K
-        self.port_a = PortState()
-        self.port_b = PortState()
+        self.port_a = self.register_port(
+            PortState.pneumatic("port_a", nominal_role="inlet")
+        )
+        self.port_b = self.register_port(
+            PortState.pneumatic("port_b", nominal_role="outlet")
+        )
 
     @property
     def K_eff(self) -> float:
@@ -26,3 +32,37 @@ class Orifice(AlgebraicComponent):
             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"]
+

PythonModels/components/pipe.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
+
 from PythonModels.core.base import DynamicComponent
+from PythonModels.core.equations import EquationResidual
 from PythonModels.core.medium import IdealGasMedium, ThermodynamicProperties
 from PythonModels.core.ports import PortState
 from PythonModels.core.state import VolumeState
@@ -29,8 +32,12 @@ class Pipe(DynamicComponent):
         m0 = p0 * self.V / (medium.R_gas * T0)
         U0 = m0 * medium.specific_internal_energy(T0)
         self.state = VolumeState(m=m0, U=U0)
-        self.port_a = PortState()
-        self.port_b = PortState()
+        self.port_a = self.register_port(
+            PortState.pneumatic("port_a", nominal_role="inlet")
+        )
+        self.port_b = self.register_port(
+            PortState.pneumatic("port_b", nominal_role="outlet")
+        )
 
     def get_state_vector(self) -> list[float]:
         return self.state.as_vector()
@@ -45,11 +52,64 @@ class Pipe(DynamicComponent):
         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_connections(
+            port_a_m_flow=self.port_a.m_flow,
+            connected_h_a=connected_h["port_a"],
+            port_b_m_flow=self.port_b.m_flow,
+            connected_h_b=connected_h["port_b"],
+            internal_h=properties.h,
+        )
+        return derivative.as_vector()
+
     def inlet_pressure(self, m_flow_a: float, rho: float, core_pressure: float) -> float:
         resistance = self.lambda_darcy * (self.L / self.D)
         dynamic_term = m_flow_a * abs(m_flow_a) / (2.0 * rho * self.area * self.area)
         return core_pressure + resistance * dynamic_term
 
+    def pressure_flow_equation_residuals(self) -> tuple[EquationResidual, ...]:
+        properties = self.medium.properties_from_mU(
+            self.state.m,
+            self.state.U,
+            self.V,
+        )
+        expected_inlet_pressure = self.inlet_pressure(
+            self.port_a.m_flow,
+            max(properties.rho, 1e-12),
+            properties.p,
+        )
+        return (
+            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_a.m_flow",
+                    f"{self.name}.state",
+                ),
+                role="effort",
+                value=self.port_a.p - expected_inlet_pressure,
+            ),
+            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 - properties.p,
+            ),
+        )
+
     def port_a_inlet_enthalpy(
         self,
         *,

PythonModels/components/resistive_pipe.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from math import pi
+
+from PythonModels.core.base import AlgebraicComponent
+from PythonModels.core.equations import EquationResidual
+from PythonModels.core.medium import IdealGasMedium
+from PythonModels.core.ports import PortState
+
+
+class ResistivePipe(AlgebraicComponent):
+    """Quasi-steady Darcy resistance used by topology-driven simulation."""
+
+    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:
+        super().__init__(name=name)
+        self.medium = medium
+        self.L = L
+        self.D = D
+        self.lambda_darcy = lambda_darcy
+        self.p0 = p0
+        self.T0 = T0
+        self.area = pi * D * D / 4.0
+        initial_h = medium.specific_enthalpy(T0)
+
+        self.port_a = PortState.pneumatic("port_a", nominal_role="inlet")
+        self.port_a.p = p0
+        self.port_a.h_outflow = initial_h
+        self.register_port(self.port_a)
+
+        self.port_b = PortState.pneumatic("port_b", nominal_role="outlet")
+        self.port_b.p = p0
+        self.port_b.h_outflow = initial_h
+        self.register_port(self.port_b)
+
+    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"]

PythonModels/components/tank.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
+
 from PythonModels.core.base import DynamicComponent
+from PythonModels.core.equations import EquationResidual
 from PythonModels.core.medium import IdealGasMedium, ThermodynamicProperties
 from PythonModels.core.ports import PortState
 from PythonModels.core.state import VolumeState
@@ -23,7 +26,9 @@ class Tank(DynamicComponent):
         m0 = p0 * V / (medium.R_gas * T0)
         U0 = m0 * medium.specific_internal_energy(T0)
         self.state = VolumeState(m=m0, U=U0)
-        self.port_a = PortState()
+        self.port_a = self.register_port(
+            PortState.pneumatic("port_a", nominal_role="inlet")
+        )
 
     def get_state_vector(self) -> list[float]:
         return self.state.as_vector()
@@ -37,6 +42,39 @@ class Tank(DynamicComponent):
         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,
         *,

PythonModels/components/tee.py

@@ -1,6 +1,9 @@
 from __future__ import annotations
 
+from collections.abc import Mapping
+
 from PythonModels.core.base import AlgebraicComponent
+from PythonModels.core.equations import EquationResidual
 from PythonModels.core.ports import PortState
 
 
@@ -9,9 +12,71 @@ class Tee(AlgebraicComponent):
 
     def __init__(self, name: str) -> None:
         super().__init__(name=name)
-        self.port_in = PortState()
-        self.port_out1 = PortState()
-        self.port_out2 = PortState()
+        self.port_in = self.register_port(
+            PortState.pneumatic("port_in", nominal_role="bidirectional")
+        )
+        self.port_out1 = self.register_port(
+            PortState.pneumatic("port_out1", nominal_role="bidirectional")
+        )
+        self.port_out2 = self.register_port(
+            PortState.pneumatic("port_out2", nominal_role="bidirectional")
+        )
+
+    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,