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

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()