修正动态管与阀门诊断输出

tests/test_amesim_pnl0001_component.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import unittest
+from math import sqrt
 
 from app.simulation.components.amesim.flow.pipes import AmesimPnl0001
 from app.simulation.core.medium import IdealGasMedium
@@ -148,6 +149,33 @@ class AmesimPnl0001ComponentTests(unittest.TestCase):
             {"m", "U", "p", "T", "rho", "u", "h", "re", "cm", "v", "ff"},
         )
 
+    def test_result_cm_excludes_pipe_flow_coefficient(self) -> None:
+        pipe = AmesimPnl0001(
+            "pnl_1",
+            self.medium,
+            diam=0.014,
+            le=0.3,
+            rr=0.045 / 14.0,
+            p0=2.5e6,
+            T0=290.0,
+        )
+        pipe.port_1.p = 1.6e6
+        props = pipe.properties()
+        flow = pipe.mass_flow(pipe.port_1.p, props.p, props.T)
+        reynolds = pipe.reynolds_number(flow, props.T)
+        friction = pipe.friction_factor(reynolds)
+        raw_cq_cm = (
+            abs(flow)
+            * sqrt(props.T)
+            / (pipe.area * max(pipe.port_1.p, props.p))
+        )
+        flow_coefficient = sqrt(pipe.diam / (pipe.le * friction))
+
+        actual = pipe.component_result_values()["cm"]
+
+        self.assertAlmostEqual(actual, raw_cq_cm / flow_coefficient)
+        self.assertNotAlmostEqual(actual, raw_cq_cm)
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_amesim_pnl0002_pnl0003_component.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import unittest
-from math import log10
+from math import log10, sqrt
 
 from app.simulation.components.amesim.flow.pipes import AmesimPnl0002, AmesimPnl0003
 from app.simulation.core.medium import IdealGasMedium
@@ -200,6 +200,79 @@ class AmesimPnl0002ComponentTests(unittest.TestCase):
         self.assertAlmostEqual(derivative[0], 0.3)
         self.assertAlmostEqual(derivative[1], 0.3 * props.h)
 
+    def test_result_cm_averages_bare_parameter_for_each_resistance(self) -> None:
+        pipe = AmesimPnl0002(
+            "pnl_2",
+            self.medium,
+            diam=0.02,
+            le=2.0,
+            rr=0.045 / 20.0,
+            p0=100000.0,
+            T0=350.0,
+        )
+        center = pipe.properties()
+        pipe.port_1.p = 130000.0
+        pipe.port_2.p = 80000.0
+        pipe.update_flow_temperature_references(
+            {
+                "port_1": self.medium.specific_enthalpy_at_pressure(
+                    pipe.port_1.p,
+                    250.0,
+                ),
+                "port_2": self.medium.specific_enthalpy_at_pressure(
+                    pipe.port_2.p,
+                    450.0,
+                ),
+            }
+        )
+
+        raw_parameters: list[float] = []
+        bare_parameters: list[float] = []
+        frictions: list[float] = []
+        for port_name, port in (
+            ("port_1", pipe.port_1),
+            ("port_2", pipe.port_2),
+        ):
+            flow = pipe.port_mass_flow(
+                port.p,
+                center.p,
+                center.T,
+                port_name=port_name,
+            )
+            if flow >= 0.0:
+                upstream_pressure = port.p
+                upstream_temperature = pipe.medium.temperature_from_pressure_enthalpy(
+                    port.p,
+                    pipe._connected_h[port_name],
+                )
+            else:
+                upstream_pressure = center.p
+                upstream_temperature = center.T
+            reynolds = pipe.reynolds_number(flow, upstream_temperature)
+            friction = pipe.friction_factor(reynolds)
+            raw = (
+                abs(flow)
+                * sqrt(upstream_temperature)
+                / (pipe.area * upstream_pressure)
+            )
+            flow_coefficient = sqrt(
+                pipe.diam / (pipe.resistance_length * friction)
+            )
+            raw_parameters.append(raw)
+            bare_parameters.append(raw / flow_coefficient)
+            frictions.append(friction)
+
+        expected = sum(bare_parameters) / 2.0
+        collapsed = (sum(raw_parameters) / 2.0) / sqrt(
+            pipe.diam
+            / (pipe.resistance_length * (sum(frictions) / 2.0))
+        )
+
+        actual = pipe.component_result_values()["cm"]
+
+        self.assertAlmostEqual(actual, expected)
+        self.assertGreater(abs(actual - collapsed), 1.0e-8)
+
 
 class AmesimPnl0003ComponentTests(unittest.TestCase):
     def setUp(self) -> None:
@@ -389,6 +462,36 @@ class AmesimPnl0003ComponentTests(unittest.TestCase):
         self.assertIn("dmctr", values)
         self.assertIn("re", values)
 
+    def test_result_cm_excludes_center_resistance_flow_coefficient(self) -> None:
+        pipe = AmesimPnl0003(
+            "pnl_3",
+            self.medium,
+            diam=0.02,
+            le=0.3,
+            rr=0.045 / 20.0,
+            p1_0=10.7e6,
+            T1_0=263.4,
+            p2_0=10.68e6,
+            T2_0=263.42,
+        )
+        port_1 = pipe.properties_1()
+        port_2 = pipe.properties_2()
+        flow = pipe.resistance_mass_flow()
+        upstream = port_1 if flow >= 0.0 else port_2
+        reynolds = pipe.reynolds_number(flow, upstream.T)
+        friction = pipe.friction_factor(reynolds)
+        raw_cq_cm = (
+            abs(flow)
+            * sqrt(upstream.T)
+            / (pipe.area * max(port_1.p, port_2.p))
+        )
+        flow_coefficient = sqrt(pipe.diam / (pipe.le * friction))
+
+        actual = pipe.component_result_values()["cm"]
+
+        self.assertAlmostEqual(actual, raw_cq_cm / flow_coefficient)
+        self.assertNotAlmostEqual(actual, raw_cq_cm)
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_amesim_pnvo001_fixed_component.py

@@ -54,6 +54,25 @@ class AmesimPnvo001FixedOpeningComponentTests(unittest.TestCase):
 
         self.assertEqual(valve.mass_flow(500000.0, 100000.0), 0.0)
 
+    def test_closed_opening_only_zeroes_reported_gas_velocity(self) -> None:
+        valve = AmesimPnvo001FixedOpening("valve_1", self.medium, opening=0.0)
+        valve.port_2.p = 500000.0
+        valve.port_3.p = 100000.0
+
+        closed = valve.component_result_values()
+        self.assertGreater(closed["cm"], 0.0)
+        self.assertEqual(closed["gasvel"], 0.0)
+
+        valve.opening = 7.0e-15
+        roundoff_closed = valve.component_result_values()
+        self.assertEqual(roundoff_closed["gasvel"], 0.0)
+        self.assertEqual(roundoff_closed["cm"], closed["cm"])
+
+        valve.opening = 1.0e-9
+        genuinely_open = valve.component_result_values()
+        self.assertNotEqual(genuinely_open["gasvel"], 0.0)
+        self.assertEqual(genuinely_open["cm"], closed["cm"])
+
     def test_mass_flow_is_bidirectional_by_pressure_order(self) -> None:
         valve = AmesimPnvo001FixedOpening("valve_1", self.medium, opening=0.5)
 

tests/test_amesim_pnvo001_signal_xml.py

@@ -244,6 +244,8 @@ class AmesimPnvo001SignalXmlTests(unittest.TestCase):
         self.assertEqual(result["series"]["step_1.out.signal"][at_event], 1.0)
         self.assertEqual(result["series"]["valve_1.xv"][before_event], 0.0)
         self.assertEqual(result["series"]["valve_1.xv"][at_event], 1.0)
+        self.assertEqual(result["series"]["valve_1.gasvel"][before_event], 0.0)
+        self.assertNotEqual(result["series"]["valve_1.gasvel"][at_event], 0.0)
         self.assertGreater(
             result["series"]["valve_1.port_2.m_flow"][at_event],
             0.45,