Add support for using (v,e) interpolation tables in THM

modules/fluid_properties/doc/content/source/fluidproperties/TabulatedFluidProperties.md

@@ -105,7 +105,7 @@ divided into 50 and 100 equal points, respectively, then the input file syntax n
   []
   [tabulated]
     type = TabulatedBicubicFluidProperties
-    fp = co2
+    input_fp = co2
     fluid_property_output_file = fluid_properties.csv
     interpolated_properties = 'density enthalpy viscosity'
 
@@ -216,7 +216,7 @@ reachable values.
 
 To avoid the difficulties in converting from (v,e) to (pressure, temperature) and then evaluating the properties
 with (pressure, temperature), the properties can also be interpolated in (v,e). These interpolations can be created
-from either another `FluidProperties` object, with the [!param](/FluidProperties/TabulatedFluidProperties/fp), or from a
+from either another `FluidProperties` object, with the [!param](/FluidProperties/TabulatedFluidProperties/input_fp), or from a
 (specific volume, specific internal energy) tabulation, using the [!param](/FluidProperties/TabulatedFluidProperties/fluid_property_ve_file) parameter.
 
 Similarly as for (pressure, temperature), the list of properties to interpolate should be provided using the [!param](/FluidProperties/TabulatedFluidProperties/interpolated_properties) parameter.

modules/fluid_properties/include/fluidproperties/SinglePhaseFluidProperties.h

@@ -447,6 +447,8 @@ class SinglePhaseFluidProperties : public FluidProperties
   const Real _p_initial_guess;
   /// Maximum number of iterations for the variable conversion newton solves
   const unsigned int _max_newton_its;
+  /// Whether to output information about newton solves to console
+  const bool _verbose_newton;
 
 private:
   void unimplementedDerivativeMethod(const std::string & property_function_name) const
@@ -528,8 +530,19 @@ SinglePhaseFluidProperties::p_T_from_v_e(const CppType & v, // v value
                       CppType & de_dT) { e_from_p_T(pressure, temperature, new_e, de_dp, de_dT); };
   try
   {
-    FluidPropertiesUtils::NewtonSolve2D(
-        v, e, p0, T0, p, T, _tolerance, _tolerance, v_lambda, e_lambda);
+    FluidPropertiesUtils::NewtonSolve2D(v,
+                                        e,
+                                        p0,
+                                        T0,
+                                        p,
+                                        T,
+                                        _tolerance,
+                                        _tolerance,
+                                        v_lambda,
+                                        e_lambda,
+                                        "p_T_from_v_e",
+                                        _max_newton_its,
+                                        _verbose_newton);
     conversion_succeeded = true;
   }
   catch (MooseException &)
@@ -557,8 +570,19 @@ SinglePhaseFluidProperties::p_T_from_v_h(const T & v,     // v value
   { h_from_p_T(pressure, temperature, new_h, dh_dp, dh_dT); };
   try
   {
-    FluidPropertiesUtils::NewtonSolve2D(
-        v, h, p0, T0, pressure, temperature, _tolerance, _tolerance, v_lambda, h_lambda);
+    FluidPropertiesUtils::NewtonSolve2D(v,
+                                        h,
+                                        p0,
+                                        T0,
+                                        pressure,
+                                        temperature,
+                                        _tolerance,
+                                        _tolerance,
+                                        v_lambda,
+                                        h_lambda,
+                                        "p_T_from_v_h",
+                                        _max_newton_its,
+                                        _verbose_newton);
     conversion_succeeded = true;
   }
   catch (MooseException &)
@@ -586,8 +610,19 @@ SinglePhaseFluidProperties::p_T_from_h_s(const T & h,     // h value
   { s_from_p_T(pressure, temperature, new_s, ds_dp, ds_dT); };
   try
   {
-    FluidPropertiesUtils::NewtonSolve2D(
-        h, s, p0, T0, pressure, temperature, _tolerance, _tolerance, h_lambda, s_lambda);
+    FluidPropertiesUtils::NewtonSolve2D(h,
+                                        s,
+                                        p0,
+                                        T0,
+                                        pressure,
+                                        temperature,
+                                        _tolerance,
+                                        _tolerance,
+                                        h_lambda,
+                                        s_lambda,
+                                        "p_T_from_h_s",
+                                        _max_newton_its,
+                                        _verbose_newton);
     conversion_succeeded = true;
   }
   catch (MooseException &)

modules/fluid_properties/include/fluidproperties/TabulatedFluidProperties.h

@@ -39,6 +39,8 @@ class TabulatedFluidProperties : public SinglePhaseFluidProperties
 
   virtual Real rho_from_p_T(Real pressure, Real temperature) const override;
 
+  virtual ADReal rho_from_p_T(const ADReal & pressure, const ADReal & temperature) const override;
+
   virtual void rho_from_p_T(
       Real pressure, Real temperature, Real & rho, Real & drho_dp, Real & drho_dT) const override;
   virtual void rho_from_p_T(const ADReal & pressure,
@@ -53,21 +55,29 @@ class TabulatedFluidProperties : public SinglePhaseFluidProperties
 
   virtual Real v_from_p_T(Real pressure, Real temperature) const override;
 
+  virtual ADReal v_from_p_T(const ADReal & pressure, const ADReal & temperature) const override;
+
   virtual void
   v_from_p_T(Real pressure, Real temperature, Real & v, Real & dv_dp, Real & dv_dT) const override;
 
   virtual Real e_from_p_T(Real pressure, Real temperature) const override;
 
+  virtual ADReal e_from_p_T(const ADReal & pressure, const ADReal & temperature) const override;
+
   virtual void
   e_from_p_T(Real pressure, Real temperature, Real & e, Real & de_dp, Real & de_dT) const override;
 
   virtual Real e_from_p_rho(Real pressure, Real rho) const override;
 
+  virtual ADReal e_from_p_rho(const ADReal & pressure, const ADReal & rho) const override;
+
   virtual void
   e_from_p_rho(Real pressure, Real rho, Real & e, Real & de_dp, Real & de_drho) const override;
 
   virtual Real T_from_p_rho(Real pressure, Real rho) const;
 
+  virtual ADReal T_from_p_rho(const ADReal & pressure, const ADReal & rho) const;
+
   virtual void T_from_p_rho(Real pressure, Real rho, Real & T, Real & dT_dp, Real & dT_drho) const;
 
   virtual Real h_from_p_T(Real p, Real T) const override;
@@ -135,8 +145,18 @@ class TabulatedFluidProperties : public SinglePhaseFluidProperties
    */
   virtual Real p_from_v_e(Real v, Real e) const override;
   virtual void p_from_v_e(Real v, Real e, Real & p, Real & dp_dv, Real & dp_de) const override;
+  virtual void p_from_v_e(const ADReal & v,
+                          const ADReal & e,
+                          ADReal & p,
+                          ADReal & dp_dv,
+                          ADReal & dp_de) const override;
   virtual Real T_from_v_e(Real v, Real e) const override;
   virtual void T_from_v_e(Real v, Real e, Real & T, Real & dT_dv, Real & dT_de) const override;
+  virtual void T_from_v_e(const ADReal & v,
+                          const ADReal & e,
+                          ADReal & p,
+                          ADReal & dp_dv,
+                          ADReal & dp_de) const override;
   virtual Real c_from_v_e(Real v, Real e) const override;
   virtual void c_from_v_e(Real v, Real e, Real & c, Real & dc_dv, Real & dc_de) const override;
   virtual Real cp_from_v_e(Real v, Real e) const override;
@@ -154,6 +174,7 @@ class TabulatedFluidProperties : public SinglePhaseFluidProperties
   virtual Real T_from_p_s(Real p, Real s) const;
   virtual void T_from_p_s(Real p, Real s, Real & T, Real & dT_dp, Real & dT_ds) const;
   virtual Real s_from_v_e(Real v, Real e) const override;
+  virtual void s_from_v_e(Real v, Real e, Real & s, Real & ds_dv, Real & ds_de) const override;
   virtual Real s_from_h_p(Real h, Real pressure) const override;
   virtual void
   s_from_h_p(Real h, Real pressure, Real & s, Real & ds_dh, Real & ds_dp) const override;
@@ -190,8 +211,10 @@ class TabulatedFluidProperties : public SinglePhaseFluidProperties
 
   /**
    * Checks initial guess for Newton Method
+   * @param post_reading_tabulation whether the check is performed at construction (false) or after
+   * reading a file tabulation (true)
    */
-  virtual void checkInitialGuess() const;
+  virtual void checkInitialGuess(bool post_reading_tabulation) const;
 
   /// Read tabulation data from file
   void readFileTabulationData(bool use_pT);
@@ -239,8 +262,15 @@ class TabulatedFluidProperties : public SinglePhaseFluidProperties
   /// Standardized error message for missing interpolation
   void missingVEInterpolationError(const std::string & function_name) const;
 
-  // Utility to forward errors related to fluid properties methods not implemented
-  [[noreturn]] void FluidPropertiesForwardError(const std::string & desired_routine) const;
+  /// Utility to forward errors related to fluid properties methods not implemented
+  [[noreturn]] void TabulationNotImplementedError(const std::string & desired_routine) const;
+  /// Utility to forward errors related to fluid properties needing more data for their computation
+  /// This should generally be used as an 'else' condition to if (_interpolate_property) / else if (_fp)
+  [[noreturn]] void NeedTabulationOrFPError(const std::string & desired_routine,
+                                            const std::string & needed_property) const;
+  /// Utility to forward errors related to properties being requested for tabulation, but no tabulation is present
+  /// This should generally be used as an 'else' condition to if (_interpolate_needed_property)
+  [[noreturn]] void NeedTabulationError(const std::string & needed_property) const;
 
   /// File name of input tabulated data file
   FileName _file_name_in;
@@ -264,9 +294,9 @@ class TabulatedFluidProperties : public SinglePhaseFluidProperties
   /// Specific enthalpy vector
   std::vector<Real> _enthalpy;
 
-  /// Whether to create direct (p,T) interpolations
+  /// Whether the object has direct (p,T) interpolations (whether created from file or from _fp)
   const bool _create_direct_pT_interpolations;
-  /// Whether to create direct (v,e) interpolations
+  /// Whether the object has direct (v,e) interpolations (whether created from file or from _fp)
   const bool _create_direct_ve_interpolations;
 
   /// Tabulated fluid properties (read from file OR computed from _fp)