实现test_mql PNL0003与PNL00R管路

PythonModels/systems/test_mql.py

@@ -3860,6 +3860,8 @@ class TestMqlSystem:
         self.archive_path = archive_path or Path(__file__).resolve().parents[2] / AMESIM_ARCHIVE_RELATIVE_PATH
         self.network = SimulationNetwork(name=MODEL_NAME)
         self.pnl0001_assembly = self._build_pnl0001_assembly()
+        self.pnl0003_assembly = self._build_pnl0003_assembly()
+        self.pnl00r_assembly = self._build_pnl00r_assembly()
         self.node3_assembly = self._build_node3_assembly()
         self.pneumatic_assembly = self._build_pneumatic_assembly()
         pneumatic_components = self._pneumatic_components_by_alias()
@@ -3890,6 +3892,20 @@ class TestMqlSystem:
 
         return build_test_mql_pnl0001_assembly(self.archive_path)
 
+    def _build_pnl0003_assembly(self):
+        from PythonModels.systems.test_mql_pneumatic_lines import (
+            build_test_mql_pnl0003_assembly,
+        )
+
+        return build_test_mql_pnl0003_assembly(self.archive_path)
+
+    def _build_pnl00r_assembly(self):
+        from PythonModels.systems.test_mql_pneumatic_lines import (
+            build_test_mql_pnl00r_assembly,
+        )
+
+        return build_test_mql_pnl00r_assembly(self.archive_path)
+
     @staticmethod
     def _build_node3_assembly():
         from PythonModels.systems.test_mql_nodes import build_test_mql_node3_assembly
@@ -3912,6 +3928,14 @@ class TestMqlSystem:
     def typed_pnl0001_line_count(self) -> int:
         return len(self.pnl0001_assembly.lines)
 
+    @property
+    def typed_pnl0003_line_count(self) -> int:
+        return len(self.pnl0003_assembly.lines)
+
+    @property
+    def typed_pnl00r_line_count(self) -> int:
+        return len(self.pnl00r_assembly.lines)
+
     @property
     def typed_node3_count(self) -> int:
         return len(self.node3_assembly)

PythonModels/systems/test_mql_line_parameters.py

@@ -35,6 +35,48 @@ class TestMqlPnl0001Spec:
         return self.initial_gauge_pressure_pa + AMESIM_REFERENCE_PRESSURE_PA
 
 
+@dataclass(frozen=True)
+class TestMqlPnl0003Spec:
+    alias: str
+    source_component: str
+    source_port: str
+    target_component: str
+    target_port: str
+    diameter_mm: float
+    length_m: float
+    relative_roughness: float
+    polytropic_constant: float
+    heat_transfer_coefficient: float
+    external_temperature_k: float
+    gas_type_index: int
+    mode: int
+    initial_temperature_1_k: float
+    initial_gauge_pressure_1_pa: float
+    initial_temperature_2_k: float
+    initial_gauge_pressure_2_pa: float
+
+    @property
+    def initial_absolute_pressure_1_pa(self) -> float:
+        return self.initial_gauge_pressure_1_pa + AMESIM_REFERENCE_PRESSURE_PA
+
+    @property
+    def initial_absolute_pressure_2_pa(self) -> float:
+        return self.initial_gauge_pressure_2_pa + AMESIM_REFERENCE_PRESSURE_PA
+
+
+@dataclass(frozen=True)
+class TestMqlPnl00rSpec:
+    alias: str
+    source_component: str
+    source_port: str
+    target_component: str
+    target_port: str
+    diameter_mm: float
+    length_m: float
+    relative_roughness: float
+    gas_type_index: int
+
+
 def load_test_mql_pnl0001_specs(
     archive_path: str | Path,
     *,
@@ -111,6 +153,145 @@ def load_test_mql_pnl0001_specs(
     return tuple(specs)
 
 
+def load_test_mql_pnl0003_specs(
+    archive_path: str | Path,
+    *,
+    cir_member: str = "test_mql_.cir",
+) -> tuple[TestMqlPnl0003Spec, ...]:
+    """Load resolved PNL0003 geometry and both compliance initial states."""
+    with tarfile.open(archive_path) as archive:
+        cir_file = archive.extractfile(cir_member)
+        if cir_file is None:
+            raise ValueError(f"Missing AMESim circuit member: {cir_member}")
+        cir_text = cir_file.read().decode("latin1")
+
+    numeric_globals = {
+        name: value
+        for name, expression in GLOBAL_PARAMETERS.items()
+        if (value := resolve_numeric_expression(expression, {})) is not None
+    }
+    connections = {
+        str(connection["alias"]): connection
+        for connection in CONNECTION_SPECS
+        if connection["submodel"] == "PNL0003"
+    }
+    specs = []
+    for block in re.findall(r"<LINE>.*?</LINE>", cir_text, flags=re.DOTALL):
+        if _optional_text(block, "SUB_NAME") != "PNL0003":
+            continue
+        alias = _required_text(block, "ALIAS")
+        connection = connections.get(alias)
+        if connection is None:
+            raise ValueError(f"PNL0003 line {alias!r} is absent from CONNECTION_SPECS")
+        real_parameters = _parameter_expressions(block, "RPARAM")
+        integer_parameters = _parameter_expressions(block, "IPARAM")
+        state_values = _evar_values(block)
+        specs.append(
+            TestMqlPnl0003Spec(
+                alias=alias,
+                source_component=str(connection["source_component"]),
+                source_port=str(connection["source_port"]),
+                target_component=str(connection["target_component"]),
+                target_port=str(connection["target_port"]),
+                diameter_mm=_required_numeric(
+                    alias, "diam", real_parameters, numeric_globals
+                ),
+                length_m=_required_numeric(alias, "le", real_parameters, numeric_globals),
+                relative_roughness=_required_numeric(
+                    alias, "rr", real_parameters, numeric_globals
+                ),
+                polytropic_constant=_required_numeric(
+                    alias, "k", real_parameters, numeric_globals
+                ),
+                heat_transfer_coefficient=_required_numeric(
+                    alias, "kth", real_parameters, numeric_globals
+                ),
+                external_temperature_k=_required_numeric(
+                    alias, "extemp", real_parameters, numeric_globals
+                ),
+                gas_type_index=int(
+                    _required_numeric(alias, "gi", integer_parameters, numeric_globals)
+                ),
+                mode=int(
+                    _required_numeric(alias, "mode", integer_parameters, numeric_globals)
+                ),
+                initial_temperature_1_k=_required_numeric(
+                    alias, "t1", state_values, numeric_globals
+                ),
+                initial_gauge_pressure_1_pa=_required_numeric(
+                    alias, "p1", state_values, numeric_globals
+                ),
+                initial_temperature_2_k=_required_numeric(
+                    alias, "t2", state_values, numeric_globals
+                ),
+                initial_gauge_pressure_2_pa=_required_numeric(
+                    alias, "p2", state_values, numeric_globals
+                ),
+            )
+        )
+    if set(connections) != {spec.alias for spec in specs}:
+        missing = sorted(set(connections) - {spec.alias for spec in specs})
+        raise ValueError(f"Missing PNL0003 parameter blocks: {missing}")
+    return tuple(specs)
+
+
+def load_test_mql_pnl00r_specs(
+    archive_path: str | Path,
+    *,
+    cir_member: str = "test_mql_.cir",
+) -> tuple[TestMqlPnl00rSpec, ...]:
+    """Load resolved PNL00R geometry from the AMESim source."""
+    with tarfile.open(archive_path) as archive:
+        cir_file = archive.extractfile(cir_member)
+        if cir_file is None:
+            raise ValueError(f"Missing AMESim circuit member: {cir_member}")
+        cir_text = cir_file.read().decode("latin1")
+
+    numeric_globals = {
+        name: value
+        for name, expression in GLOBAL_PARAMETERS.items()
+        if (value := resolve_numeric_expression(expression, {})) is not None
+    }
+    connections = {
+        str(connection["alias"]): connection
+        for connection in CONNECTION_SPECS
+        if connection["submodel"] == "PNL00R"
+    }
+    specs = []
+    for block in re.findall(r"<LINE>.*?</LINE>", cir_text, flags=re.DOTALL):
+        if _optional_text(block, "SUB_NAME") != "PNL00R":
+            continue
+        alias = _required_text(block, "ALIAS")
+        connection = connections.get(alias)
+        if connection is None:
+            raise ValueError(f"PNL00R line {alias!r} is absent from CONNECTION_SPECS")
+        real_parameters = _parameter_expressions(block, "RPARAM")
+        integer_parameters = _parameter_expressions(block, "IPARAM")
+        specs.append(
+            TestMqlPnl00rSpec(
+                alias=alias,
+                source_component=str(connection["source_component"]),
+                source_port=str(connection["source_port"]),
+                target_component=str(connection["target_component"]),
+                target_port=str(connection["target_port"]),
+                diameter_mm=_required_numeric(
+                    alias, "diam", real_parameters, numeric_globals
+                ),
+                length_m=_required_numeric(alias, "le", real_parameters, numeric_globals),
+                relative_roughness=_required_numeric(
+                    alias, "rr", real_parameters, numeric_globals
+                ),
+                gas_type_index=int(
+                    _required_numeric(alias, "gi", integer_parameters, numeric_globals)
+                ),
+            )
+        )
+    if set(connections) != {spec.alias for spec in specs}:
+        missing = sorted(set(connections) - {spec.alias for spec in specs})
+        raise ValueError(f"Missing PNL00R parameter blocks: {missing}")
+    return tuple(specs)
+
+
 def _parameter_expressions(block: str, tag_name: str) -> dict[str, str]:
     parameters = {}
     for parameter_block in re.findall(
@@ -141,11 +322,11 @@ def _required_numeric(
     variables: dict[str, float],
 ) -> float:
     if name not in expressions:
-        raise ValueError(f"Missing {name!r} on PNL0001 line {alias!r}")
+        raise ValueError(f"Missing {name!r} on line {alias!r}")
     value = resolve_numeric_expression(expressions[name], variables)
     if value is None:
         raise ValueError(
-            f"Cannot resolve {name!r}={expressions[name]!r} on PNL0001 line {alias!r}"
+            f"Cannot resolve {name!r}={expressions[name]!r} on line {alias!r}"
         )
     return value
 

PythonModels/systems/test_mql_pneumatic_lines.py

@@ -7,10 +7,18 @@ from PythonModels.components.amesim_pneumatic import (
     HELIUM_PNEUMATIC_GAS,
     AmesimPneumaticGas,
 )
-from PythonModels.components.amesim_pneumatic_line import AmesimPnl0001Pipe
+from PythonModels.components.amesim_pneumatic_line import (
+    AmesimPnl0001Pipe,
+    AmesimPnl0003Pipe,
+    AmesimPnl00rPipe,
+)
 from PythonModels.systems.test_mql_line_parameters import (
     TestMqlPnl0001Spec,
+    TestMqlPnl0003Spec,
+    TestMqlPnl00rSpec,
     load_test_mql_pnl0001_specs,
+    load_test_mql_pnl0003_specs,
+    load_test_mql_pnl00r_specs,
 )
 
 
@@ -26,6 +34,30 @@ class TestMqlPnl0001Assembly:
         raise KeyError(alias)
 
 
+@dataclass(frozen=True)
+class TestMqlPnl0003Assembly:
+    specs: tuple[TestMqlPnl0003Spec, ...]
+    lines: dict[str, AmesimPnl0003Pipe]
+
+    def spec(self, alias: str) -> TestMqlPnl0003Spec:
+        for spec in self.specs:
+            if spec.alias == alias:
+                return spec
+        raise KeyError(alias)
+
+
+@dataclass(frozen=True)
+class TestMqlPnl00rAssembly:
+    specs: tuple[TestMqlPnl00rSpec, ...]
+    lines: dict[str, AmesimPnl00rPipe]
+
+    def spec(self, alias: str) -> TestMqlPnl00rSpec:
+        for spec in self.specs:
+            if spec.alias == alias:
+                return spec
+        raise KeyError(alias)
+
+
 def build_test_mql_pnl0001_assembly(
     archive_path: str | Path,
     *,
@@ -48,3 +80,48 @@ def build_test_mql_pnl0001_assembly(
         for spec in specs
     }
     return TestMqlPnl0001Assembly(specs=specs, lines=lines)
+
+
+def build_test_mql_pnl0003_assembly(
+    archive_path: str | Path,
+    *,
+    gas: AmesimPneumaticGas = HELIUM_PNEUMATIC_GAS,
+) -> TestMqlPnl0003Assembly:
+    specs = load_test_mql_pnl0003_specs(archive_path)
+    lines = {
+        spec.alias: AmesimPnl0003Pipe(
+            name=spec.alias,
+            diameter_mm=spec.diameter_mm,
+            length_m=spec.length_m,
+            relative_roughness=spec.relative_roughness,
+            polytropic_constant=spec.polytropic_constant,
+            heat_transfer_coefficient=spec.heat_transfer_coefficient,
+            external_temperature_k=spec.external_temperature_k,
+            gas=gas,
+            p1_0=spec.initial_absolute_pressure_1_pa,
+            T1_0=spec.initial_temperature_1_k,
+            p2_0=spec.initial_absolute_pressure_2_pa,
+            T2_0=spec.initial_temperature_2_k,
+        )
+        for spec in specs
+    }
+    return TestMqlPnl0003Assembly(specs=specs, lines=lines)
+
+
+def build_test_mql_pnl00r_assembly(
+    archive_path: str | Path,
+    *,
+    gas: AmesimPneumaticGas = HELIUM_PNEUMATIC_GAS,
+) -> TestMqlPnl00rAssembly:
+    specs = load_test_mql_pnl00r_specs(archive_path)
+    lines = {
+        spec.alias: AmesimPnl00rPipe(
+            name=spec.alias,
+            diameter_mm=spec.diameter_mm,
+            length_m=spec.length_m,
+            relative_roughness=spec.relative_roughness,
+            gas=gas,
+        )
+        for spec in specs
+    }
+    return TestMqlPnl00rAssembly(specs=specs, lines=lines)