renamed Vdot_g0 and ndot_g0

Author: hmonroedd

examples/sparging_standard.py

@@ -49,6 +49,7 @@
     # P = output.exported_fields["pressure"]
     # plt.plot(output.x_ct, P)
     # output.exports_to_csv(FOLDER)
+    output.export = ["pressure, "]
 
     output.profiles_to_csv(FOLDER)
     output.profiles_to_cdf(FOLDER)

src/sparging/correlations.py

@@ -32,7 +32,7 @@ class CorrelationType(enum.Enum):  # TODO do we really use it ?
     BUBBLE_VELOCITY = "v_g0"
     GAS_PHASE_DISPERSION = "E_g"
     LIQUID_PHASE_DISPERSION = "E_l"
-    FLOW_RATE = "flow_g_mol"
+    FLOW_RATE = "ndot_g0"
     INTERFACIAL_AREA = "a"
     TRITIUM_SOURCE = "source_T"
     LIQUID_PRESSURE_PROFILE = "P_l"
@@ -235,8 +235,8 @@ def get_list(self, corr_type: CorrelationType) -> list[Correlation]:
 
 d_b0 = Correlation(
     identifier="d_b0",
-    function=lambda flow_g_vol, nozzle_diameter, nb_nozzle: get_d_b0(
-        flow_g_vol=flow_g_vol, nozzle_diameter=nozzle_diameter, nb_nozzle=nb_nozzle
+    function=lambda Vdot_g0, nozzle_diameter, nb_nozzle: get_d_b0(
+        Vdot_g0=Vdot_g0, nozzle_diameter=nozzle_diameter, nb_nozzle=nb_nozzle
     ),  # mean bubble diameter, Kanai 2017
     corr_type=CorrelationType.BUBBLE_DIAMETER,
     input_units=["m**3/s", "m", "dimensionless"],
@@ -311,7 +311,7 @@ def get_list(self, corr_type: CorrelationType) -> list[Correlation]:
 # superficial gas velocity at the inlet
 u_g0 = Correlation(
     identifier="u_g0",
-    function=lambda flow_g_vol, area: (flow_g_vol / area).to("m/s"),
+    function=lambda Vdot_g0, area: (Vdot_g0 / area).to("m/s"),
     corr_type=CorrelationType.SUPERFICIAL_GAS_VELOCITY,
     input_units=["m^3/s", "m^2"],
     output_units="m/s",
@@ -412,17 +412,17 @@ def get_list(self, corr_type: CorrelationType) -> list[Correlation]:
 all_correlations.append(rho_g)
 
 
-flow_g_vol = Correlation(
-    identifier="flow_g_vol",
-    function=lambda flow_g_mol, temperature, P_l: (
-        flow_g_mol * const_R * temperature / P_l(0 * ureg.m)
+Vdot_g0 = Correlation(
+    identifier="Vdot_g0",
+    function=lambda ndot_g0, temperature, P_l: (
+        ndot_g0 * const_R * temperature / P_l(0 * ureg.m)
     ),  # convert molar flow rate to volumetric flow rate using ideal gas law
     corr_type=CorrelationType.FLOW_RATE,
     description="volumetric flow rate of gas phase calculated from molar flow rate using ideal gas law",
     input_units=["mol/s", "kelvin", PROFILE],
     output_units="m**3/s",
 )
-all_correlations.append(flow_g_vol)
+all_correlations.append(Vdot_g0)
 
 
 source_T_integral = Correlation(
@@ -438,12 +438,12 @@ def get_list(self, corr_type: CorrelationType) -> list[Correlation]:
 
 
 def get_d_b0(
-    flow_g_vol: pint.Quantity, nozzle_diameter: pint.Quantity, nb_nozzle: pint.Quantity
+    Vdot_g0: pint.Quantity, nozzle_diameter: pint.Quantity, nb_nozzle: pint.Quantity
 ) -> float:
     """
     mean bubble diameter [m], Kanai 2017 (reported by Evans 2026)
     """
-    nozzle_flow = flow_g_vol / nb_nozzle  # volumetric flow per nozzle [m3/s]
+    nozzle_flow = Vdot_g0 / nb_nozzle  # volumetric flow per nozzle [m3/s]
     if nozzle_flow < ureg("3 cm**3/s") or nozzle_flow > ureg("10 cm**3/s"):
         warnings.warn(
             f"nozzle flow {nozzle_flow.to('cm**3/s')} is out of the validated range for the Kanai 2017 correlation (3-10 cm3/s)"
@@ -560,11 +560,11 @@ def get_h_briggs(Re: float, Sc: float, D_l: float, d_b: float) -> float:
 
 eps_g = Profile(
     identifier="eps_g",
-    function=lambda temperature, P_g, flow_g_mol, area, v_g0: (
+    function=lambda temperature, P_g, ndot_g0, area, v_g0: (
         lambda z: get_eps_g(
             T=temperature,
             P_g=P_g(z),
-            n_g_dot=flow_g_mol,
+            n_g_dot=ndot_g0,
             area=area,
             v_g=v_g0,
         )

src/sparging/input_examples.py

@@ -35,7 +35,7 @@ def get_sim_input_LIBRA1L() -> tuple[SimulationInput, pint.Quantity]:
     operating_params = OperatingParameters(
         temperature=600 * ureg.celsius,
         P_top=1 * ureg.atm,
-        flow_g_mol=40 * ureg.sccm,
+        ndot_g0=40 * ureg.sccm,
         tbr=2e-3 * ureg("triton / neutron"),  # according to LIBRA 1L paper
         n_gen_rate=1e9 * ureg("neutron / s"),
     )
@@ -75,7 +75,7 @@ def get_sim_input_standard() -> SimulationInput:
     operating_params = OperatingParameters(
         temperature=600 * ureg.celsius,
         P_top=1 * ureg.atm,
-        flow_g_mol=400 * ureg.sccm,
+        ndot_g0=400 * ureg.sccm,
         tbr=0.1 * ureg("triton / neutron"),
         n_gen_rate=1e9 * ureg("neutron / s"),
     )
@@ -109,7 +109,7 @@ def get_sim_input_malara() -> SimulationInput:
     operating_params = OperatingParameters(
         temperature=623 * ureg.kelvin,
         P_top=5e5 * ureg.pascal,
-        flow_g_mol=0.19 * ureg("mol / s"),
+        ndot_g0=0.19 * ureg("mol / s"),
         tbr=0.1 * ureg("triton / neutron"),
         n_gen_rate=1e9 * ureg("neutron / s"),
     )
@@ -142,7 +142,7 @@ def get_sim_input_malara() -> SimulationInput:
 LIBRA_PI_OPERATING_PARAMS = OperatingParameters(
     temperature=550 * ureg.celsius,
     P_top=1.2 * ureg.atm,
-    flow_g_mol=400 * ureg.sccm,
+    ndot_g0=400 * ureg.sccm,
     tbr=0.1 * ureg("triton / neutron"),
     n_gen_rate=1e9 * ureg("neutron / s"),
 )

src/sparging/inputs.py

@@ -49,9 +49,9 @@ def copy(self):
 @dataclass
 class OperatingParameters:
     temperature: pint.Quantity
-    flow_g_mol: pint.Quantity
+    ndot_g0: pint.Quantity
     P_top: pint.Quantity
-    flow_g_vol: pint.Quantity | None = None
+    Vdot_g0: pint.Quantity | None = None
     P_bottom: pint.Quantity | Correlation | None = None
     tbr: pint.Quantity | None = None
     n_gen_rate: pint.Quantity | None = None
@@ -198,16 +198,14 @@ def get_Bo(self) -> pint.Quantity:
         """
         # return (self.eps_g * self.u_g0 * self.height / self.E_g).to("dimensionless")
         return (
-            (self.graph.nodes["flow_g_vol"]["value"] / self.area)
-            * self.height
-            / self.E_g
+            (self.graph.nodes["Vdot_g0"]["value"] / self.area) * self.height / self.E_g
         ).to("dimensionless")
 
     def test_eps_g(
         self,
     ):  # to see if the two definitions of superficial velocity are consistent -> TODO remove
         print(
-            f"{self.eps_g_0 * self.graph.nodes['v_g0']['value']} vs {self.graph.nodes['flow_g_vol']['value'] / self.area} vs {self.graph.nodes['u_g0']['value']}"
+            f"{self.eps_g_0 * self.graph.nodes['v_g0']['value']} vs {self.graph.nodes['Vdot_g0']['value'] / self.area} vs {self.graph.nodes['u_g0']['value']}"
         )
 
     def __post_init__(self):

test/test_simulation_input.py

@@ -33,7 +33,7 @@
 operating_params = OperatingParameters(
     temperature=600 * ureg.celsius,
     P_top=1 * ureg.atm,
-    flow_g_mol=400 * ureg.sccm,
+    ndot_g0=400 * ureg.sccm,
     tbr=0.1 * ureg("triton / neutron"),
     n_gen_rate=1e9 * ureg("neutron / s"),
 )
@@ -132,13 +132,13 @@ def test_find_in_graph_result(in_discovered: bool):
     Test finding a node in the graph.
     This test checks that the `find_in_graph` function can successfully find the `d_b` parameter
     using the provided `ColumnGeometry` and `OperatingParameters`. It also tests both cases where
-    `flow_g_vol` is provided in the discovered nodes and where it is not, ensuring that the
+    `Vdot_g0` is provided in the discovered nodes and where it is not, ensuring that the
     function can handle both scenarios correctly.
     """
     # BUILD
     discovered_graph = nx.Graph()
     if in_discovered:
-        discovered_graph.add_node("flow_g_vol", value=0.01 * ureg.m**3 / ureg.s)
+        discovered_graph.add_node("Vdot_g0", value=0.01 * ureg.m**3 / ureg.s)
 
     # RUN
     find_in_graph(
@@ -152,9 +152,9 @@ def test_find_in_graph_result(in_discovered: bool):
 
     correlation = sparging.all_correlations("d_b")
 
-    flow_g_vol = discovered_graph.nodes["flow_g_vol"]["value"]
+    Vdot_g0 = discovered_graph.nodes["Vdot_g0"]["value"]
     expected_value = correlation(
-        flow_g_vol=flow_g_vol,
+        Vdot_g0=Vdot_g0,
         nozzle_diameter=geom.nozzle_diameter,
         nb_nozzle=geom.nb_nozzle,
     )
@@ -164,7 +164,7 @@ def test_find_in_graph_result(in_discovered: bool):
     )
 
 
-@pytest.mark.parametrize("missing_param", ("nb_nozzle", "flow_g_mol", "n_gen_rate"))
+@pytest.mark.parametrize("missing_param", ("nb_nozzle", "ndot_g0", "n_gen_rate"))
 def test_find_in_graph_unresolvable(missing_param: str):
     """
     Test that find_in_graph raises an error when a parameter cannot be resolved.
@@ -178,7 +178,7 @@ def test_find_in_graph_unresolvable(missing_param: str):
         case "nb_nozzle":
             to_find = "d_b"
             setattr(broken_geom, missing_param, None)
-        case "flow_g_mol":
+        case "ndot_g0":
             to_find = "d_b"
             setattr(broken_op_params, missing_param, None)
         case "n_gen_rate":
@@ -199,13 +199,13 @@ def test_find_in_graph_unresolvable(missing_param: str):
         )
 
 
-@pytest.mark.parametrize("required_node", ("flow_g_mol", "non_existent_param"))
+@pytest.mark.parametrize("required_node", ("ndot_g0", "non_existent_param"))
 def test_check_input_none(required_node: str):
     """
     Test that check_input returns None when the required node is not found in the graph.
     """
     # BUILD
-    broken_op_params = dataclasses.replace(operating_params, flow_g_mol=None)
+    broken_op_params = dataclasses.replace(operating_params, ndot_g0=None)
     # RUN
     result = check_input(required_node, [geom, broken_op_params])
     # TEST