校准第二支路热流体能量与管路摩擦

tests/test_amesim_pneumatic_node_components.py

@@ -68,7 +68,7 @@ class AmesimPneumaticNodeComponentTests(unittest.TestCase):
             ),
         )
 
-    def test_node_stream_outflow_uses_incoming_weighted_mix(self) -> None:
+    def test_node_uses_port_2_temperature_for_non_reference_outlets(self) -> None:
         node = AmesimP4Node2("p4_1")
         node.port_1.m_flow = 0.25
         node.port_2.m_flow = 0.75
@@ -84,10 +84,44 @@ class AmesimPneumaticNodeComponentTests(unittest.TestCase):
             }
         )
 
-        self.assertEqual(node.port_1.h_outflow, 250.0)
+        self.assertEqual(node.temperature_reference_h, 300.0)
+        self.assertEqual(node.port_1.h_outflow, 300.0)
         self.assertEqual(node.port_2.h_outflow, 250.0)
-        self.assertEqual(node.port_3.h_outflow, 250.0)
-        self.assertEqual(node.port_4.h_outflow, 250.0)
+        self.assertEqual(node.port_3.h_outflow, 300.0)
+        self.assertEqual(node.port_4.h_outflow, 300.0)
+
+    def test_port_2_outlet_closes_node_energy_balance(self) -> None:
+        node = AmesimP4Node2("p4_1")
+        node.port_1.m_flow = -0.01823
+        node.port_2.m_flow = -2.56077
+        node.port_3.m_flow = 2.579
+        node.port_4.m_flow = 0.0
+
+        node.update_stream_outflows(
+            {
+                "port_1": 2_630_000.0,
+                "port_2": 140_900.0,
+                "port_3": 63_960.0,
+                "port_4": 0.0,
+            }
+        )
+
+        self.assertEqual(node.port_1.h_outflow, 140_900.0)
+        energy_flow = sum(
+            port.m_flow
+            * (
+                {
+                    "port_1": 2_630_000.0,
+                    "port_2": 140_900.0,
+                    "port_3": 63_960.0,
+                    "port_4": 0.0,
+                }[name]
+                if port.m_flow > 0.0
+                else port.h_outflow
+            )
+            for name, port in node.ports.items()
+        )
+        self.assertAlmostEqual(energy_flow, 0.0, places=10)
 
 
 if __name__ == "__main__":

tests/test_amesim_pnl0002_pnl0003_component.py

@@ -151,6 +151,23 @@ class AmesimPnl0002ComponentTests(unittest.TestCase):
 
         self.assertAlmostEqual(derivative[0], 0.1)
 
+    def test_connection_derivative_uses_energy_balanced_node_enthalpy(self) -> None:
+        pipe = AmesimPnl0002("pnl_2", self.medium)
+        props = pipe.properties()
+        pipe.port_1.m_flow = 0.2
+        pipe.port_2.m_flow = 0.1
+        reference_h = props.h + 10_000.0
+        pipe.update_flow_temperature_references(
+            {"port_1": reference_h, "port_2": reference_h}
+        )
+
+        derivative = pipe.state_derivative_from_ports(
+            {"port_1": props.h, "port_2": props.h}
+        )
+
+        self.assertAlmostEqual(derivative[0], 0.3)
+        self.assertAlmostEqual(derivative[1], 0.3 * props.h)
+
 
 class AmesimPnl0003ComponentTests(unittest.TestCase):
     def setUp(self) -> None:

tests/test_amesim_pnl00r_component.py

@@ -66,6 +66,50 @@ class AmesimPnl00rComponentTests(unittest.TestCase):
         self.assertGreater(pipe.friction_factor(100000.0), 0.0)
         self.assertLess(pipe.friction_factor(100000.0), 0.1)
 
+    def test_friction_factor_matches_amesim_smooth_to_rough_transition(self) -> None:
+        pipe_20mm = AmesimPnl00r(
+            "pnl_20mm",
+            self.medium,
+            diam=0.02,
+            rr=0.045 / 20.0,
+        )
+        pipe_14mm = AmesimPnl00r(
+            "pnl_14mm",
+            self.medium,
+            diam=0.014,
+            rr=0.045 / 14.0,
+        )
+
+        self.assertAlmostEqual(
+            pipe_20mm.friction_factor(56_887.5547),
+            0.0215740061043,
+            delta=8.0e-5,
+        )
+        self.assertAlmostEqual(
+            pipe_20mm.friction_factor(700_686.41),
+            0.02400535718,
+            delta=8.0e-5,
+        )
+        self.assertAlmostEqual(
+            pipe_14mm.friction_factor(726_799.66),
+            0.02658268645,
+            delta=8.0e-5,
+        )
+
+    def test_friction_factor_matches_amesim_transition_regime(self) -> None:
+        pipe = AmesimPnl00r(
+            "pnl_20mm",
+            self.medium,
+            diam=0.02,
+            rr=0.045 / 20.0,
+        )
+
+        self.assertAlmostEqual(
+            pipe.friction_factor(3_699.80236),
+            0.0391257647759,
+            delta=4.0e-4,
+        )
+
     def test_darcy_pressure_drop_uses_flow_sign(self) -> None:
         pipe = AmesimPnl00r("pnl_1", self.medium)
         density = self.medium.density(500000.0, 300.0)

tests/test_component_catalog.py

@@ -465,7 +465,7 @@ class ComponentCatalogTests(unittest.TestCase):
                 component = self.components[model_type]
                 model_parameters = parameters(model_type)
                 expected_version = (
-                    "0.3.0" if model_type == "amesim_pnl0002" else "0.2.0"
+                    "0.5.0" if model_type == "amesim_pnl0002" else "0.3.0"
                 )
                 self.assertEqual(component["modelVersion"], expected_version)
                 self.assertEqual(model_parameters["mode"]["editor"], "choice")

tests/test_mechanical_solver_causalization.py

@@ -396,8 +396,38 @@ class MechanicalSolverCausalizationTests(unittest.TestCase):
         self.assertAlmostEqual(result.series["mass.v"][0], -0.5 * mass.dvel)
         self.assertLess(min(result.series["mass.x"]), 0.0)
         self.assertLessEqual(max(result.series["mass.x"]), 1.0e-15)
-        self.assertAlmostEqual(result.series["mass.x"][-1], 0.0, places=15)
-        self.assertAlmostEqual(result.series["mass.v"][-1], 0.0, places=15)
+        self.assertAlmostEqual(result.series["mass.x"][-1], 0.0, delta=5.0e-15)
+        self.assertAlmostEqual(result.series["mass.v"][-1], 0.0, delta=1.1e-12)
+
+    def test_ideal_upper_stop_ignores_jacobian_scale_inward_velocity_noise(self) -> None:
+        system, mass = _single_mass_system(
+            100.0,
+            stoptype=1.0,
+            x0=0.0,
+            xmin=-1.0,
+            xmax=0.0,
+        )
+        initial_state = system.consistent_initial_state_vector()
+        perturbed_state = [-1.0e-14, initial_state[1]]
+
+        self.assertEqual(system.rhs(0.0, initial_state), [0.0, 0.0])
+        self.assertEqual(system.rhs(0.0, perturbed_state), [0.0, 0.0])
+        self.assertEqual(mass.v, -1.0e-14)
+
+    def test_ideal_lower_stop_ignores_jacobian_scale_outward_velocity_noise(self) -> None:
+        system, mass = _single_mass_system(
+            -100.0,
+            stoptype=1.0,
+            x0=0.0,
+            xmin=0.0,
+            xmax=1.0,
+        )
+        initial_state = system.consistent_initial_state_vector()
+        perturbed_state = [1.0e-14, initial_state[1]]
+
+        self.assertEqual(system.rhs(0.0, initial_state), [0.0, 0.0])
+        self.assertEqual(system.rhs(0.0, perturbed_state), [0.0, 0.0])
+        self.assertEqual(mass.v, 1.0e-14)
 
     def test_ideal_stop_rejects_initial_position_outside_limits(self) -> None:
         system, _mass = _single_mass_system(

tests/test_pressure_flow_solver_initialization.py

@@ -183,9 +183,11 @@ class PressureFlowSolverInitializationTests(unittest.TestCase):
         first = system.rhs(0.0, state)
         second = system.rhs(0.0, state)
 
-        self.assertGreater(system.max_thermofluid_iterations, 1)
+        # PN3NODE2 takes its pressure-flow temperature reference from port 2,
+        # so that closure no longer depends on the flow-weighted energy mix.
+        self.assertGreaterEqual(system.max_thermofluid_iterations, 1)
         for first_value, second_value in zip(first, second):
-            self.assertAlmostEqual(first_value, second_value, places=10)
+            self.assertAlmostEqual(first_value, second_value, delta=1.0e-8)
 
     def test_current_storage_pressure_reseeds_stale_orifice_ports_and_flow(self) -> None:
         network, medium, high, low, valve = self._near_equal_pressure_network()