[DOCFL] Corrected the documentation for fluid property keywords.

MaterialLib/Fluid/Density/LinearTemperatureDependentDensity.h

@@ -28,16 +28,14 @@ namespace Fluid
 class LinearTemperatureDependentDensity final : public FluidProperty
 {
 public:
-    /** \param parameters An array contains the three parameters:
-     *                     [0] $f\rho_0$f
-     *                     [1] $fT_0$f
-     *                     [2] $f\beta$f
+    /**
+     * @param rho0  \f$ \rho_0 \f$
+     * @param T0    \f$ T_0 \f$
+     * @param beta  \f$ \beta \f$
      */
-    explicit LinearTemperatureDependentDensity(
-        std::array<double, 3> const& parameters)
-        : _rho0(parameters[0]),
-          _temperature0(parameters[1]),
-          _beta(parameters[2])
+    explicit LinearTemperatureDependentDensity(const double rho0, double T0,
+                                               const double beta)
+        : _rho0(rho0), _temperature0(T0), _beta(beta)
     {
     }
 

MaterialLib/Fluid/Density/LiquidDensity.h

@@ -52,19 +52,16 @@ namespace Fluid
 class LiquidDensity final : public FluidProperty
 {
 public:
-    /** \param parameters An array contains the five parameters:
-     *                     [0] $f \beta $f
-     *                     [1] $f \rho_0 $f
-     *                     [2] $f T_0 $f
-     *                     [3] $f p_0 $f
-     *                     [4] $f E_0 $f
+    /**
+     * @param beta \$f \beta \f$
+     * @param rho  \$f \rho_0 \f$
+     * @param T0   \$f T_0 \f$
+     * @param p0   \$f p_0 \f$
+     * @param E    \$f E \f$
      */
-    explicit LiquidDensity(std::array<double, 5> const& parameters)
-        : _beta(parameters[0]),
-          _rho0(parameters[1]),
-          _temperature0(parameters[2]),
-          _p0(parameters[3]),
-          _bulk_modulus(parameters[4])
+    explicit LiquidDensity(const double beta, const double rho0,
+                           const double T0, const double p0, const double E)
+        : _beta(beta), _rho0(rho0), _temperature0(T0), _p0(p0), _bulk_modulus(E)
     {
     }
 

MaterialLib/Fluid/Density/createFluidDensityModel.cpp

@@ -26,55 +26,62 @@ namespace Fluid
 {
 /*!
     \param config  ConfigTree object which contains the input data
-                   including  <type>fluid</type> and it has
+                   including  <type>LiquidDensity</type> and it has
                    a tag of <density>
 */
 static std::unique_ptr<FluidProperty> createLiquidDensity(
     BaseLib::ConfigTree const& config)
 {
-    std::array<double, 5> parameters = {
-        {//! \ogs_file_param{material__fluid__density__liquid_density__beta}
-         config.getConfigParameter<double>("beta"),
-         //! \ogs_file_param{material__fluid__density__liquid_density__rho0}
-         config.getConfigParameter<double>("rho0"),
-         //! \ogs_file_param{material__fluid__density__liquid_density__temperature0}
-         config.getConfigParameter<double>("temperature0"),
-         //! \ogs_file_param{material__fluid__density__liquid_density__p0}
-         config.getConfigParameter<double>("p0"),
-         //! \ogs_file_param{material__fluid__density__liquid_density__bulk_modulus}
-         config.getConfigParameter<double>("bulk_modulus")}};
-    return std::unique_ptr<FluidProperty>(new LiquidDensity(parameters));
+    //! \ogs_file_param{material__fluid__density__LiquidDensity}
+    config.checkConfigParameter("type", "LiquidDensity");
+
+    //! \ogs_file_param{material__fluid__density__LiquidDensity__beta}
+    const double beta = config.getConfigParameter<double>("beta");
+    //! \ogs_file_param{material__fluid__density__LiquidDensity__rho0}
+    const double rho0 = config.getConfigParameter<double>("rho0");
+    //! \ogs_file_param{material__fluid__density__LiquidDensity__temperature0}
+    const double T0 = config.getConfigParameter<double>("temperature0");
+    //! \ogs_file_param{material__fluid__density__LiquidDensity__p0}
+    const double p0 = config.getConfigParameter<double>("p0");
+    //! \ogs_file_param{material__fluid__density__LiquidDensity__bulk_modulus}
+    const double E = config.getConfigParameter<double>("bulk_modulus");
+    return std::unique_ptr<FluidProperty>(
+        new LiquidDensity(beta, rho0, T0, p0, E));
 }
 
 /*!
     \param config  ConfigTree object which contains the input data
-                   including  <type>fluid</type> and it has
+                   including  <type>TemperatureDependent</type> and it has
                    a tag of <density>
 */
 static std::unique_ptr<FluidProperty> createLinearTemperatureDependentDensity(
     BaseLib::ConfigTree const& config)
 {
-    std::array<double, 3> parameters = {
-        {//! \ogs_file_param{material__fluid__density__linear_temperature__rho0}
-         config.getConfigParameter<double>("rho0"),
-         //! \ogs_file_param{material__fluid__density__linear_temperature__temperature0}
-         config.getConfigParameter<double>("temperature0"),
-         //! \ogs_file_param{material__fluid__density__linear_temperature__beta}
-         config.getConfigParameter<double>("beta")}};
+    //! \ogs_file_param{material__fluid__density__TemperatureDependent}
+    config.checkConfigParameter("type", "TemperatureDependent");
+
+    //! \ogs_file_param{material__fluid__density__TemperatureDependent__rho0}
+    const double rho0 = config.getConfigParameter<double>("rho0");
+    //! \ogs_file_param{material__fluid__density__TemperatureDependent__temperature0}
+    const double T0 = config.getConfigParameter<double>("temperature0");
+    //! \ogs_file_param{material__fluid__density__TemperatureDependent__beta}
+    const double beta = config.getConfigParameter<double>("beta");
     return std::unique_ptr<FluidProperty>(
-        new LinearTemperatureDependentDensity(parameters));
+        new LinearTemperatureDependentDensity(rho0, T0, beta));
 }
 
 std::unique_ptr<FluidProperty> createFluidDensityModel(
     BaseLib::ConfigTree const& config)
 {
     //! \ogs_file_param{material__fluid__density__type}
-    auto const type = config.getConfigParameter<std::string>("type");
+    auto const type = config.peekConfigParameter<std::string>("type");
 
     if (type == "Constant")
     {
+        //! \ogs_file_param{material__fluid__density__Constant}
+        config.checkConfigParameter("type", "Constant");
         return std::unique_ptr<FluidProperty>(new ConstantFluidProperty(
-            //! \ogs_file_param{material__fluid__density__value}
+            //! \ogs_file_param{material__fluid__density__Constant__value}
             config.getConfigParameter<double>("value")));
     }
     else if (type == "LiquidDensity")
@@ -83,6 +90,8 @@ std::unique_ptr<FluidProperty> createFluidDensityModel(
         return createLinearTemperatureDependentDensity(config);
     else if (type == "IdealGasLaw")
     {
+        //! \ogs_file_param{material__fluid__density__IdealGasLaw}
+        config.checkConfigParameter("type", "IdealGasLaw");
         return std::unique_ptr<FluidProperty>(
             //! \ogs_file_param{material__fluid__density__IdealGasLaw__molar_mass}
             new IdealGasLaw(config.getConfigParameter<double>("molar_mass")));

MaterialLib/Fluid/Viscosity/LinearPressureDependentViscosity.h

@@ -35,14 +35,15 @@ namespace Fluid
 class LinearPressureDependentViscosity final : public FluidProperty
 {
 public:
-    /** \param parameters An array contains the three parameters:
-     *                     [0] $f\mu_0$f
-     *                     [1] $fp_0$f
-     *                     [2] $f\gamma$f
+    /**
+     *  @param mu0   \f$ \mu_0 \f$
+     *  @param p0    \f$ p_0 \f$
+     *  @param gamma \f$ \gamma \f$
      */
-    explicit LinearPressureDependentViscosity(
-        std::array<double, 3> const& parameters)
-        : _mu0(parameters[0]), _p0(parameters[1]), _gamma(parameters[2])
+    explicit LinearPressureDependentViscosity(const double mu0,
+                                              const double p0,
+                                              const double gamma)
+        : _mu0(mu0), _p0(p0), _gamma(gamma)
     {
     }
 

MaterialLib/Fluid/Viscosity/TemperatureDependentViscosity.h

@@ -41,16 +41,15 @@ namespace Fluid
 class TemperatureDependentViscosity final : public FluidProperty
 {
 public:
-    /** \param parameters An array contains the three parameters:
-     *                     [0] $f\mu_0$f
-     *                     [1] $fT_c$f
-     *                     [2] $fT_v$f
+    /**
+     *  @param mu0   \f$ \mu_0 \f$
+     *  @param T_c   \f$ T_c \f$
+     *  @param T_v   \f$ T_v \f$
      */
-    explicit TemperatureDependentViscosity(
-        std::array<double, 3> const& parameters)
-        : _mu0(parameters[0]),
-          _temperature_c(parameters[1]),
-          _temperature_v(parameters[2])
+    explicit TemperatureDependentViscosity(const double mu0,
+                                           const double T_c,
+                                           const double T_v)
+        : _mu0(mu0), _temperature_c(T_c), _temperature_v(T_v)
     {
     }
 

MaterialLib/Fluid/Viscosity/VogelsLiquidDynamicViscosity.h

@@ -26,7 +26,8 @@ namespace MaterialLib
 namespace Fluid
 {
 /** A temperature dependent viscosity model.
- * <a href="ddbst"> http://ddbonline.ddbst.de/VogelCalculation/VogelCalculationCGI.exe</a>
+ * <a href="ddbst">
+ * http://ddbonline.ddbst.de/VogelCalculation/VogelCalculationCGI.exe</a>
  */
 template <typename VogelsConstants>
 class VogelsLiquidDynamicViscosity final : public FluidProperty
@@ -82,7 +83,8 @@ private:
 };
 
 /**  Parameters A, B, C.
- *  <a href="ddbst"> http://ddbonline.ddbst.de/VogelCalculation/VogelCalculationCGI.exe</a>
+ *  <a href="ddbst">
+ * http://ddbonline.ddbst.de/VogelCalculation/VogelCalculationCGI.exe</a>
  * */
 struct VogelsViscosityConstantsWater
 {

MaterialLib/Fluid/Viscosity/createViscosityModel.cpp

@@ -26,64 +26,84 @@ namespace Fluid
 {
 /**
  *     \param config  ConfigTree object which contains the input data
- *                    including  <type>fluid</type> and it has
+ *                    including  <type>LinearPressure</type> and it has
  *                    a tag of <viscosity>
  */
 static std::unique_ptr<FluidProperty> createLinearPressureDependentViscosity(
     BaseLib::ConfigTree const& config)
 {
-    std::array<double, 3> parameters = {
-        {//! \ogs_file_param{material__fluid__viscosity__temperature_dependent__mu0}
-         config.getConfigParameter<double>("mu0"),
-         //! \ogs_file_param{material__fluid__viscosity__temperature_dependent__p0}
-         config.getConfigParameter<double>("p0"),
-         //! \ogs_file_param{material__fluid__viscosity__temperature_dependent__gamma}
-         config.getConfigParameter<double>("gamma")}};
+    //! \ogs_file_param{material__fluid__viscosity__LinearPressure}
+    config.checkConfigParameter("type", "LinearPressure");
+
+    //! \ogs_file_param{material__fluid__viscosity__LinearPressure__mu0}
+    const double mu0 = config.getConfigParameter<double>("mu0");
+
+    //! \ogs_file_param{material__fluid__viscosity__LinearPressure__p0}
+    const double p0 = config.getConfigParameter<double>("p0");
+
+    //! \ogs_file_param{material__fluid__viscosity__LinearPressure__gamma}
+    const double gamma = config.getConfigParameter<double>("gamma");
+
     return std::unique_ptr<FluidProperty>(
-        new LinearPressureDependentViscosity(parameters));
+        new LinearPressureDependentViscosity(mu0, p0, gamma));
 }
 
 /**
  *     \param config  ConfigTree object which contains the input data
- *                    including  <type>fluid</type> and it has
+ *                    including  <type>TemperatureDependent</type> and it has
  *                    a tag of <viscosity>
  */
 static std::unique_ptr<FluidProperty> createTemperatureDependentViscosity(
     BaseLib::ConfigTree const& config)
 {
-    std::array<double, 3> parameters = {
-        {//! \ogs_file_param{material__fluid__viscosity__temperature_dependent__mu0}
-         config.getConfigParameter<double>("mu0"),
-         //! \ogs_file_param{material__fluid__viscosity__temperature_dependent__tc}
-         config.getConfigParameter<double>("tc"),
-         //! \ogs_file_param{material__fluid__viscosity__temperature_dependent__tv}
-         config.getConfigParameter<double>("tv")}};
+    //! \ogs_file_param{material__fluid__viscosity__TemperatureDependent}
+    config.checkConfigParameter("type", "TemperatureDependent");
+
+    //! \ogs_file_param{material__fluid__viscosity__TemperatureDependent__mu0}
+    const double mu0 = config.getConfigParameter<double>("mu0");
+
+    //! \ogs_file_param{material__fluid__viscosity__TemperatureDependent__tc}
+    const double Tc = config.getConfigParameter<double>("tc");
+
+    //! \ogs_file_param{material__fluid__viscosity__TemperatureDependent__tv}
+    const double Tv = config.getConfigParameter<double>("tv");
+
     return std::unique_ptr<FluidProperty>(
-        new TemperatureDependentViscosity(parameters));
+        new TemperatureDependentViscosity(mu0, Tc, Tv));
 }
 
 std::unique_ptr<FluidProperty> createViscosityModel(
     BaseLib::ConfigTree const& config)
 {
     //! \ogs_file_param{material__fluid__viscosity__type}
-    auto const type = config.getConfigParameter<std::string>("type");
+    auto const type = config.peekConfigParameter<std::string>("type");
 
     if (type == "Constant")
+    {
+        //! \ogs_file_param{material__fluid__viscosity__Constant}
+        config.checkConfigParameter("type", "Constant");
         return std::unique_ptr<FluidProperty>(new ConstantFluidProperty(
             //! \ogs_file_param{material__fluid__viscosity__Constant__value}
             config.getConfigParameter<double>("value")));
+    }
     else if (type == "LinearPressure")
         return createLinearPressureDependentViscosity(config);
     else if (type == "TemperatureDependent")
         return createTemperatureDependentViscosity(config);
     else if (type == "Vogels")
     {
+        //! \ogs_file_param{material__fluid__viscosity__Vogels}
+        config.checkConfigParameter("type", "Vogels");
+
         INFO("Using Vogels model, which gives viscosity in SI unit, Pa s");
         auto const fluid_type =
             //! \ogs_file_param{material__fluid__viscosity__Vogels__liquid_type}
-            config.getConfigParameter<std::string>("liquid_type");
+            config.peekConfigParameter<std::string>("liquid_type");
         if (fluid_type == "Water")
         {
+            //! \ogs_file_param{material__fluid__viscosity__Vogels__Water}
+            config.checkConfigParameter("liquid_type", "Water");
+
             const VogelsViscosityConstantsWater constants;
             return std::unique_ptr<FluidProperty>(
                 new VogelsLiquidDynamicViscosity<VogelsViscosityConstantsWater>(
@@ -91,6 +111,8 @@ std::unique_ptr<FluidProperty> createViscosityModel(
         }
         else if (fluid_type == "CO2")
         {
+            //! \ogs_file_param{material__fluid__viscosity__Vogels__CO2}
+            config.checkConfigParameter("liquid_type", "CO2");
             const VogelsViscosityConstantsCO2 constants;
             return std::unique_ptr<FluidProperty>(
                 new VogelsLiquidDynamicViscosity<VogelsViscosityConstantsCO2>(
@@ -98,6 +120,8 @@ std::unique_ptr<FluidProperty> createViscosityModel(
         }
         else if (fluid_type == "CH4")
         {
+            //! \ogs_file_param{material__fluid__viscosity__Vogels__CH4}
+            config.checkConfigParameter("liquid_type", "CH4");
             const VogelsViscosityConstantsCH4 constants;
             return std::unique_ptr<FluidProperty>(
                 new VogelsLiquidDynamicViscosity<VogelsViscosityConstantsCH4>(