436 lines
16 KiB
Python
436 lines
16 KiB
Python
from __future__ import annotations
|
|
|
|
import unittest
|
|
|
|
from app.simulation.components.amesim.flow.pipes import AmesimPnl00r
|
|
from app.simulation.components.amesim.junctions.nodes import AmesimPn3Node2
|
|
from app.simulation.components.experimental.storage.cylinder import Cylinder
|
|
from app.simulation.components.experimental.storage.tank import Tank
|
|
from app.simulation.core.medium import IdealGasMedium
|
|
from app.simulation.registry import COMPONENT_MODEL_REGISTRY
|
|
from app.simulation.solvers.stream import StreamResolver
|
|
from app.simulation.systems.network import SimulationNetwork
|
|
|
|
|
|
class AmesimPnl00rComponentTests(unittest.TestCase):
|
|
def setUp(self) -> None:
|
|
self.medium = IdealGasMedium()
|
|
|
|
def test_default_create_preserves_amesim_parameter_contract(self) -> None:
|
|
pipe = COMPONENT_MODEL_REGISTRY["amesim_pnl00r"].create(
|
|
"pnl_1",
|
|
self.medium,
|
|
{},
|
|
)
|
|
|
|
self.assertIsInstance(pipe, AmesimPnl00r)
|
|
self.assertEqual(set(pipe.ports), {"port_1", "port_2"})
|
|
self.assertEqual(set(pipe.parameter_values), {"diam", "le", "rr", "gi"})
|
|
self.assertEqual(pipe.parameter_values["diam"], 0.01)
|
|
self.assertEqual(pipe.gi, 0)
|
|
|
|
def test_rejects_fractional_gas_index(self) -> None:
|
|
with self.assertRaisesRegex(ValueError, "gi must be an integer"):
|
|
COMPONENT_MODEL_REGISTRY["amesim_pnl00r"].create(
|
|
"pnl_1",
|
|
self.medium,
|
|
{"gi": 1.5},
|
|
)
|
|
|
|
def test_initial_flow_temperature_reference_preserves_default_behavior(self) -> None:
|
|
pipe = AmesimPnl00r("pnl_1", self.medium)
|
|
initial_h = self.medium.specific_enthalpy(self.medium.T_ref)
|
|
|
|
self.assertEqual(
|
|
pipe._connected_h,
|
|
{"port_1": initial_h, "port_2": initial_h},
|
|
)
|
|
self.assertAlmostEqual(pipe._port_temperature("port_1"), self.medium.T_ref)
|
|
self.assertAlmostEqual(pipe._port_temperature("port_2"), self.medium.T_ref)
|
|
|
|
forward = pipe.mass_flow(501000.0, 500000.0)
|
|
reverse = pipe.mass_flow(500000.0, 501000.0)
|
|
self.assertGreater(forward, 0.0)
|
|
self.assertLess(reverse, 0.0)
|
|
self.assertAlmostEqual(forward, -reverse, delta=abs(forward) * 0.02)
|
|
|
|
def test_zero_pressure_drop_has_zero_flow_and_finite_results(self) -> None:
|
|
pipe = AmesimPnl00r("pnl_1", self.medium)
|
|
pipe.port_1.p = 100000.0
|
|
pipe.port_2.p = 100000.0
|
|
pipe.port_1.m_flow = 0.0
|
|
pipe.port_2.m_flow = 0.0
|
|
|
|
residuals = {
|
|
residual.id.rsplit(":", 1)[1]: residual
|
|
for residual in pipe.pressure_flow_equation_residuals()
|
|
}
|
|
|
|
self.assertEqual(pipe.mass_flow(100000.0, 100000.0), 0.0)
|
|
self.assertEqual(residuals["mass_flow_balance"].value, 0.0)
|
|
self.assertEqual(residuals["pressure_flow_relation"].value, 0.0)
|
|
self.assertEqual(set(pipe.component_result_values()), {"re", "cm", "v", "ff"})
|
|
|
|
def test_mass_flow_is_bidirectional_by_pressure_order(self) -> None:
|
|
pipe = AmesimPnl00r("pnl_1", self.medium, diam=0.014, le=1.0, rr=0.045 / 14.0)
|
|
|
|
forward = pipe.mass_flow(501000.0, 500000.0)
|
|
reverse = pipe.mass_flow(500000.0, 501000.0)
|
|
|
|
self.assertGreater(forward, 0.0)
|
|
self.assertLess(reverse, 0.0)
|
|
self.assertAlmostEqual(forward, -reverse, delta=abs(forward) * 0.02)
|
|
|
|
def test_mass_flow_is_continuous_across_former_relative_deadband(self) -> None:
|
|
pipe = AmesimPnl00r("pnl_1", self.medium, diam=0.014, le=1.0, rr=0.045 / 14.0)
|
|
base_pressure = 8.0e6
|
|
former_threshold = base_pressure * 1.0e-7
|
|
|
|
below = pipe.mass_flow(base_pressure + 0.99 * former_threshold, base_pressure)
|
|
above = pipe.mass_flow(base_pressure + 1.01 * former_threshold, base_pressure)
|
|
reverse = pipe.mass_flow(base_pressure, base_pressure + 0.99 * former_threshold)
|
|
|
|
self.assertGreater(below, 0.0)
|
|
self.assertGreater(above, below)
|
|
self.assertLess(reverse, 0.0)
|
|
self.assertAlmostEqual(below, -reverse, delta=abs(below) * 1.0e-9)
|
|
self.assertLess(abs(above - below), abs(above) * 0.05)
|
|
self.assertEqual(pipe.mass_flow(base_pressure, base_pressure), 0.0)
|
|
self.assertGreater(pipe.mass_flow(15.3e6 + 0.1, 15.3e6), 0.0)
|
|
|
|
|
|
def test_pressure_drop_inversion_cache_keys_all_property_inputs(self) -> None:
|
|
pipe = AmesimPnl00r(
|
|
"pnl_1",
|
|
self.medium,
|
|
diam=0.014,
|
|
le=1.0,
|
|
rr=0.045 / 14.0,
|
|
)
|
|
pipe.update_flow_temperature_references(
|
|
{
|
|
"port_1": self.medium.specific_enthalpy(300.0),
|
|
"port_2": self.medium.specific_enthalpy(300.0),
|
|
}
|
|
)
|
|
pipe._mass_flow_for_pressure_drop.cache_clear()
|
|
|
|
first = pipe.mass_flow(501000.0, 500000.0)
|
|
after_first = pipe._mass_flow_for_pressure_drop.cache_info()
|
|
second = pipe.mass_flow(501000.0, 500000.0)
|
|
after_second = pipe._mass_flow_for_pressure_drop.cache_info()
|
|
pipe.update_flow_temperature_references(
|
|
{
|
|
"port_1": self.medium.specific_enthalpy(400.0),
|
|
"port_2": self.medium.specific_enthalpy(300.0),
|
|
}
|
|
)
|
|
third = pipe.mass_flow(501000.0, 500000.0)
|
|
after_temperature_change = pipe._mass_flow_for_pressure_drop.cache_info()
|
|
|
|
self.assertEqual(first, second)
|
|
self.assertEqual(after_first.misses, 1)
|
|
self.assertEqual(after_second.hits, after_first.hits + 1)
|
|
self.assertNotEqual(third, second)
|
|
self.assertEqual(
|
|
after_temperature_change.misses,
|
|
after_second.misses + 1,
|
|
)
|
|
|
|
def test_stream_outflows_are_crossed_but_flow_temperature_is_same_side(self) -> None:
|
|
pipe = AmesimPnl00r("pnl_1", self.medium)
|
|
hot_h = self.medium.specific_enthalpy(420.0)
|
|
cold_h = self.medium.specific_enthalpy(240.0)
|
|
|
|
pipe.update_stream_outflows({"port_1": hot_h, "port_2": cold_h})
|
|
|
|
self.assertEqual(pipe.port_1.h_outflow, cold_h)
|
|
self.assertEqual(pipe.port_2.h_outflow, hot_h)
|
|
self.assertEqual(pipe._connected_h, {"port_1": hot_h, "port_2": cold_h})
|
|
self.assertAlmostEqual(pipe._port_temperature("port_1"), 420.0)
|
|
self.assertAlmostEqual(pipe._port_temperature("port_2"), 240.0)
|
|
|
|
warmer_h = self.medium.specific_enthalpy(460.0)
|
|
pipe.update_flow_temperature_references(
|
|
{"port_1": warmer_h, "port_2": cold_h}
|
|
)
|
|
|
|
self.assertEqual(
|
|
pipe._connected_h,
|
|
{"port_1": warmer_h, "port_2": cold_h},
|
|
)
|
|
self.assertAlmostEqual(pipe._port_temperature("port_1"), 460.0)
|
|
# Updating the pressure-flow-only reference must not change the
|
|
# zero-volume component's already propagated connector outflows.
|
|
self.assertEqual(pipe.port_1.h_outflow, cold_h)
|
|
self.assertEqual(pipe.port_2.h_outflow, hot_h)
|
|
|
|
def test_stream_closure_refreshes_same_side_cache_before_recomputed_flow(self) -> None:
|
|
hot_temperature = 420.0
|
|
cold_temperature = 240.0
|
|
source = Cylinder(
|
|
"source",
|
|
self.medium,
|
|
V=0.02,
|
|
p0=501000.0,
|
|
T0=hot_temperature,
|
|
)
|
|
pipe = AmesimPnl00r("pnl_1", self.medium)
|
|
sink = Tank(
|
|
"sink",
|
|
self.medium,
|
|
V=0.05,
|
|
p0=500000.0,
|
|
T0=cold_temperature,
|
|
)
|
|
network = SimulationNetwork("pnl00r-stream-refresh")
|
|
for component in (source, pipe, sink):
|
|
network.add_component(component)
|
|
network.connect("source", "port_b", "pnl_1", "port_1")
|
|
network.connect("pnl_1", "port_2", "sink", "port_a")
|
|
|
|
diagnostics, connected_h = StreamResolver(network).solve()
|
|
|
|
self.assertTrue(diagnostics.converged)
|
|
self.assertEqual(pipe._connected_h, connected_h["pnl_1"])
|
|
self.assertAlmostEqual(pipe._port_temperature("port_1"), hot_temperature)
|
|
self.assertAlmostEqual(pipe._port_temperature("port_2"), cold_temperature)
|
|
|
|
# The pressure-flow layer runs again after this stream closure pass.
|
|
# Its first recomputation therefore observes the freshly cached source
|
|
# enthalpy, independently of the crossed connector outflow values.
|
|
pipe.port_1.p = source.port_b.p
|
|
pipe.port_2.p = sink.port_a.p
|
|
flow = pipe.mass_flow(pipe.port_1.p, pipe.port_2.p)
|
|
self.assertGreater(flow, 0.0)
|
|
|
|
def test_node_port_2_reference_refresh_does_not_replace_crossed_outflows(
|
|
self,
|
|
) -> None:
|
|
hot = Cylinder(
|
|
"hot",
|
|
self.medium,
|
|
V=0.1,
|
|
p0=100_000.0,
|
|
T0=400.0,
|
|
)
|
|
cold = Cylinder(
|
|
"cold",
|
|
self.medium,
|
|
V=0.1,
|
|
p0=100_000.0,
|
|
T0=200.0,
|
|
)
|
|
remote = Cylinder(
|
|
"remote",
|
|
self.medium,
|
|
V=0.1,
|
|
p0=100_000.0,
|
|
T0=300.0,
|
|
)
|
|
node = AmesimPn3Node2("node")
|
|
pipe = AmesimPnl00r("pnl_1", self.medium)
|
|
node.port_1.m_flow = 1.0
|
|
node.port_2.m_flow = -1.0
|
|
node.port_3.m_flow = 0.0
|
|
|
|
network = SimulationNetwork("pnl00r-node-reference")
|
|
for component in (hot, cold, remote, node, pipe):
|
|
network.add_component(component)
|
|
network.connect("hot", "port_b", "node", "port_1")
|
|
network.connect("cold", "port_b", "node", "port_3")
|
|
network.connect("node", "port_2", "pnl_1", "port_1")
|
|
network.connect("pnl_1", "port_2", "remote", "port_b")
|
|
resolver = StreamResolver(network)
|
|
|
|
diagnostics, connected_h = resolver.solve()
|
|
references = resolver.connected_temperature_reference_enthalpies()
|
|
outflows_before = (pipe.port_1.h_outflow, pipe.port_2.h_outflow)
|
|
|
|
self.assertTrue(diagnostics.converged)
|
|
self.assertNotEqual(node.port_2.h_outflow, node.temperature_reference_h)
|
|
self.assertEqual(pipe._connected_h, connected_h["pnl_1"])
|
|
self.assertNotEqual(
|
|
connected_h["pnl_1"]["port_1"],
|
|
references["pnl_1"]["port_1"],
|
|
)
|
|
|
|
resolver.refresh_flow_temperature_references()
|
|
|
|
self.assertEqual(pipe._connected_h, references["pnl_1"])
|
|
self.assertEqual(
|
|
pipe._connected_h["port_1"],
|
|
node.temperature_reference_h,
|
|
)
|
|
self.assertEqual(
|
|
(pipe.port_1.h_outflow, pipe.port_2.h_outflow),
|
|
outflows_before,
|
|
)
|
|
|
|
def test_hot_and_cold_upstream_flow_results_and_equations_are_consistent(self) -> None:
|
|
pipe = AmesimPnl00r(
|
|
"pnl_1",
|
|
self.medium,
|
|
diam=0.014,
|
|
le=1.0,
|
|
rr=0.045 / 14.0,
|
|
)
|
|
hot_temperature = 420.0
|
|
cold_temperature = 240.0
|
|
pipe.update_stream_outflows(
|
|
{
|
|
"port_1": self.medium.specific_enthalpy(hot_temperature),
|
|
"port_2": self.medium.specific_enthalpy(cold_temperature),
|
|
}
|
|
)
|
|
|
|
reference_hot = AmesimPnl00r(
|
|
"reference_hot",
|
|
self.medium,
|
|
diam=pipe.diam,
|
|
le=pipe.le,
|
|
rr=pipe.rr,
|
|
)
|
|
reference_hot.update_flow_temperature_references(
|
|
{
|
|
"port_1": self.medium.specific_enthalpy(hot_temperature),
|
|
"port_2": self.medium.specific_enthalpy(hot_temperature),
|
|
}
|
|
)
|
|
reference_cold = AmesimPnl00r(
|
|
"reference_cold",
|
|
self.medium,
|
|
diam=pipe.diam,
|
|
le=pipe.le,
|
|
rr=pipe.rr,
|
|
)
|
|
reference_cold.update_flow_temperature_references(
|
|
{
|
|
"port_1": self.medium.specific_enthalpy(cold_temperature),
|
|
"port_2": self.medium.specific_enthalpy(cold_temperature),
|
|
}
|
|
)
|
|
|
|
cases = (
|
|
("forward_hot", 501000.0, 500000.0, hot_temperature, reference_hot),
|
|
("reverse_cold", 500000.0, 501000.0, cold_temperature, reference_cold),
|
|
)
|
|
for label, p_1, p_2, upstream_temperature, reference in cases:
|
|
with self.subTest(label=label):
|
|
pipe.port_1.p = p_1
|
|
pipe.port_2.p = p_2
|
|
reference.port_1.p = p_1
|
|
reference.port_2.p = p_2
|
|
expected_flow = reference.mass_flow(p_1, p_2)
|
|
actual_flow = pipe.mass_flow(p_1, p_2)
|
|
|
|
self.assertAlmostEqual(actual_flow, expected_flow)
|
|
pipe.port_1.m_flow = actual_flow
|
|
pipe.port_2.m_flow = -actual_flow
|
|
equation_values = pipe.pressure_flow_equation_values()
|
|
residual_values = tuple(
|
|
residual.value
|
|
for residual in pipe.pressure_flow_equation_residuals()
|
|
)
|
|
self.assertEqual(equation_values, (0.0, 0.0))
|
|
self.assertEqual(residual_values, equation_values)
|
|
|
|
results = pipe.component_result_values()
|
|
upstream_pressure = max(p_1, p_2)
|
|
density = self.medium.density(
|
|
upstream_pressure,
|
|
upstream_temperature,
|
|
)
|
|
expected_reynolds = pipe.reynolds_number(
|
|
actual_flow,
|
|
upstream_temperature,
|
|
)
|
|
self.assertAlmostEqual(results["re"], expected_reynolds)
|
|
self.assertAlmostEqual(
|
|
results["v"],
|
|
actual_flow / (density * pipe.area),
|
|
)
|
|
self.assertAlmostEqual(
|
|
results["cm"],
|
|
abs(actual_flow)
|
|
* upstream_temperature**0.5
|
|
/ (pipe.area * upstream_pressure),
|
|
)
|
|
self.assertAlmostEqual(
|
|
results["ff"],
|
|
min(pipe.friction_factor(expected_reynolds), 64_000_000.0),
|
|
)
|
|
|
|
def test_friction_factor_transitions_from_laminar_to_turbulent(self) -> None:
|
|
pipe = AmesimPnl00r("pnl_1", self.medium, rr=1e-5)
|
|
|
|
self.assertGreater(pipe.friction_factor(1.0e-12), 64_000_000.0)
|
|
self.assertAlmostEqual(pipe.friction_factor(100.0), 64.0 / 100.0)
|
|
self.assertGreater(pipe.friction_factor(100000.0), 0.0)
|
|
self.assertLess(pipe.friction_factor(100000.0), 0.1)
|
|
|
|
def test_reported_friction_factor_is_bounded_at_tiny_flow(self) -> None:
|
|
pipe = AmesimPnl00r("pnl_1", self.medium)
|
|
pipe.mass_flow = lambda _p_1, _p_2: 1.0e-30
|
|
|
|
self.assertEqual(pipe.component_result_values()["ff"], 64_000_000.0)
|
|
|
|
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=1.0e-4,
|
|
)
|
|
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)
|
|
|
|
forward = pipe.darcy_pressure_drop(0.01, density=density, temperature=300.0)
|
|
reverse = pipe.darcy_pressure_drop(-0.01, density=density, temperature=300.0)
|
|
|
|
self.assertGreater(forward, 0.0)
|
|
self.assertLess(reverse, 0.0)
|
|
self.assertAlmostEqual(forward, -reverse)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|