Restore dimensional output ports on GLC via update override

Author: milanofthe

src/pathsim_chem/tritium/glc.py

@@ -383,22 +383,18 @@ class GLC(BVP1D):
     transfer via Sieverts' law, and hydrostatic pressure variation along
     the column.
 
-    The block is a thin specialisation of the native
-    :class:`~pathsim.blocks.BVP1D` block: the constructor seeds the parent with
-    the Malara right-hand side and boundary conditions, and the four block
-    inputs supply the per-evaluation boundary data. The hydrodynamic
-    correlations and dimensionless groups are computed from the current input
-    inside the collocation callbacks. As for any ``BVP1D``, the solve is
-    warm-started from the previous mesh and skipped entirely when the input is
-    unchanged.
-
-    The block output is the dimensionless solution sampled at the two domain
-    endpoints (``xi=0`` liquid outlet, ``xi=1`` liquid inlet), in the
-    :class:`~pathsim.blocks.BVP1D` row-major layout
-    ``[x_T(0), x_T(1), x_T'(0), x_T'(1), y_T2(0), y_T2(1), y_T2'(0), y_T2'(1)]``.
-    Use :meth:`results` to post-process the current solution into dimensional
-    quantities (concentrations, extraction efficiency, molar flows, mass
-    balance).
+    The block is a specialisation of the native :class:`~pathsim.blocks.BVP1D`
+    block: the constructor seeds the parent with the Malara right-hand side and
+    boundary conditions, and the four block inputs supply the per-evaluation
+    boundary data. The hydrodynamic correlations and dimensionless groups are
+    computed from the current input inside the collocation callbacks. As for any
+    ``BVP1D``, the solve is warm-started from the previous mesh and skipped
+    entirely when the input is unchanged. After each solve the dimensionless
+    endpoint solution is post-processed into the dimensional output ports.
+
+    Use :meth:`results` to retrieve the full dimensional result dictionary,
+    which additionally contains partial pressures, physical properties and the
+    dimensionless groups.
 
     Reference: https://doi.org/10.13182/FST95-A30485
 
@@ -408,6 +404,16 @@ class GLC(BVP1D):
     ``y_T2_inlet`` -- T₂ mole fraction in inlet gas [-],
     ``flow_g`` -- gas mass flow rate [kg/s].
 
+    **Output ports:**
+    ``c_T_out`` -- dissolved tritium concentration in liquid outlet [mol/m³],
+    ``y_T2_out`` -- T₂ mole fraction in outlet gas [-],
+    ``eff`` -- extraction efficiency [-],
+    ``P_out`` -- total gas outlet pressure [Pa],
+    ``Q_l`` -- liquid volumetric flow rate [m³/s],
+    ``Q_g_out`` -- gas volumetric flow rate at outlet [m³/s],
+    ``n_T_out_liquid`` -- tritium molar flow in liquid outlet [mol/s],
+    ``n_T_out_gas`` -- tritium molar flow in gas outlet [mol/s].
+
     Parameters
     ----------
     P_in : float
@@ -439,6 +445,16 @@ class GLC(BVP1D):
         "y_T2_inlet": 2,
         "flow_g": 3,
         }
+    output_port_labels = {
+        "c_T_out": 0,
+        "y_T2_out": 1,
+        "eff": 2,
+        "P_out": 3,
+        "Q_l": 4,
+        "Q_g_out": 5,
+        "n_T_out_liquid": 6,
+        "n_T_out_gas": 7,
+        }
 
     def __init__(
         self,
@@ -529,6 +545,39 @@ def _bc(self, Sa, Sb, p, u):
         y_T2_in = max(u[2], 1e-20)
         return _boundary_conditions(Sa, Sb, dim, y_T2_in, self.BCs)
 
+    def update(self, t):
+        """Solve the BVP and expose the dimensional results at the output ports.
+
+        Delegates the solve to :class:`~pathsim.blocks.BVP1D` (warm-started, and
+        skipped when the input is unchanged), then post-processes the
+        dimensionless endpoint solution into the eight dimensional output ports.
+
+        Parameters
+        ----------
+        t : float
+            evaluation time
+
+        Raises
+        ------
+        RuntimeError
+            if the BVP solve did not converge
+        """
+        super().update(t)
+        if not self.success:
+            raise RuntimeError("BVP solver failed to converge.")
+
+        res = self.results()
+        self.outputs.update_from_array(np.array([
+            res["c_T_outlet [mol/m^3]"],
+            res["y_T2_outlet_gas"],
+            res["extraction_efficiency [fraction]"],
+            res["total_gas_P_outlet [Pa]"],
+            res["liquid_vol_flow [m^3/s]"],
+            res["gas_vol_flow_outlet [m^3/s]"],
+            res["tritium_out_liquid [mol/s]"],
+            res["tritium_out_gas [mol/s]"],
+        ]))
+
     def results(self):
         """Post-process the current BVP solution into dimensional results.
 

tests/tritium/test_glc.py

@@ -87,6 +87,10 @@ def test_init(self):
         self.assertEqual(len(blk.inputs), 4)
         for label in ("c_T_in", "flow_l", "y_T2_inlet", "flow_g"):
             self.assertIn(label, blk.input_port_labels)
+        #eight named dimensional output ports
+        for label in ("c_T_out", "y_T2_out", "eff", "P_out", "Q_l", "Q_g_out",
+                      "n_T_out_liquid", "n_T_out_gas"):
+            self.assertIn(label, blk.output_port_labels)
         #no successful solve yet, so no dimensional results
         self.assertIsNone(blk.results())
 
@@ -139,17 +143,25 @@ def test_results_physical(self):
                                res["Total tritium out [mol/s]"], places=12)
 
 
-    def test_output_layout(self):
-        """The block output is the dimensionless solution at the two endpoints."""
+    def test_output_ports(self):
+        """The eight dimensional output ports match the results dictionary."""
         blk = GLC(BCs="C-C", **_BASE)
         blk.inputs.update_from_array(np.array(_INPUT))
         blk.update(0.0)
 
-        #row-major [x_T(0), x_T(1), ...]; output[0] is the dimensionless outlet
-        #liquid concentration, i.e. c_T_out / c_T_in
         res = blk.results()
-        self.assertAlmostEqual(blk.outputs[0],
-                               res["c_T_outlet [mol/m^3]"] / _INPUT[0], places=12)
+        for label, key in (
+            ("c_T_out", "c_T_outlet [mol/m^3]"),
+            ("y_T2_out", "y_T2_outlet_gas"),
+            ("eff", "extraction_efficiency [fraction]"),
+            ("P_out", "total_gas_P_outlet [Pa]"),
+            ("Q_l", "liquid_vol_flow [m^3/s]"),
+            ("Q_g_out", "gas_vol_flow_outlet [m^3/s]"),
+            ("n_T_out_liquid", "tritium_out_liquid [mol/s]"),
+            ("n_T_out_gas", "tritium_out_gas [mol/s]"),
+        ):
+            idx = blk.output_port_labels[label]
+            self.assertAlmostEqual(blk.outputs[idx], res[key], places=12)
 
 
     def test_unknown_bc_raises(self):
@@ -218,7 +230,9 @@ def test_simulation(self):
             blocks=[*srcs, block, sco],
             connections=(
                 [Connection(srcs[i], block[i]) for i in range(4)]
-                + [Connection(block[0], sco[0])]
+                #connect the named efficiency output port, as a downstream
+                #consumer would
+                + [Connection(block["eff"], sco[0])]
             ),
             log=False,
         )
@@ -227,7 +241,8 @@ def test_simulation(self):
         self.assertTrue(block.success)
         res = block.results()
         np.testing.assert_allclose(
-            block.outputs[0], res["c_T_outlet [mol/m^3]"] / _INPUT[0], atol=1e-12
+            block.outputs[block.output_port_labels["eff"]],
+            res["extraction_efficiency [fraction]"], atol=1e-12
         )