CreateViscosityModel.cpp

Go to the documentation of this file.

 
#include "CreateViscosityModel.h"
 
#include "BaseLib/Error.h"
#include "LinearPressureDependentViscosity.h"
#include "MaterialLib/Fluid/ConstantFluidProperty.h"
#include "TemperatureDependentViscosity.h"
#include "VogelsLiquidDynamicViscosity.h"
#include "WaterViscosityIAPWS.h"
 
namespace MaterialLib
{
namespace Fluid
{
static std::unique_ptr<FluidProperty> createLinearPressureDependentViscosity(
    BaseLib::ConfigTree const& config)
{
    config.checkConfigParameter("type", "LinearPressure");
 
    const auto mu0 = config.getConfigParameter<double>("mu0");
 
    const auto p0 = config.getConfigParameter<double>("p0");
 
    const auto gamma = config.getConfigParameter<double>("gamma");
 
    return std::make_unique<LinearPressureDependentViscosity>(mu0, p0, gamma);
}
 
static std::unique_ptr<FluidProperty> createTemperatureDependentViscosity(
    BaseLib::ConfigTree const& config)
{
    config.checkConfigParameter("type", "TemperatureDependent");
 
    const auto mu0 = config.getConfigParameter<double>("mu0");
 
    const auto Tc = config.getConfigParameter<double>("tc");
 
    const auto Tv = config.getConfigParameter<double>("tv");
 
    return std::make_unique<TemperatureDependentViscosity>(mu0, Tc, Tv);
}
 
std::unique_ptr<FluidProperty> createViscosityModel(
    BaseLib::ConfigTree const& config)
{
    auto const type = config.peekConfigParameter<std::string>("type");
 
    if (type == "Constant")
    {
        config.checkConfigParameter("type", "Constant");
        return std::make_unique<ConstantFluidProperty>(
            config.getConfigParameter<double>("value"));
    }
    if (type == "LinearPressure")
    {
        return createLinearPressureDependentViscosity(config);
    }
    if (type == "TemperatureDependent")
    {
        return createTemperatureDependentViscosity(config);
    }
    if (type == "Vogels")
    {
        config.checkConfigParameter("type", "Vogels");
 
        INFO("Using Vogels model, which gives viscosity in SI unit, Pa s");
        auto const fluid_type =
            config.peekConfigParameter<std::string>("liquid_type");
        if (fluid_type == "Water")
        {
            config.checkConfigParameter("liquid_type", "Water");
 
            const VogelsViscosityConstantsWater constants;
            return std::make_unique<
                VogelsLiquidDynamicViscosity<VogelsViscosityConstantsWater>>(
                constants);
        }
        if (fluid_type == "CO2")
        {
            config.checkConfigParameter("liquid_type", "CO2");
            const VogelsViscosityConstantsCO2 constants;
            return std::make_unique<
                VogelsLiquidDynamicViscosity<VogelsViscosityConstantsCO2>>(
                constants);
        }
        if (fluid_type == "CH4")
        {
            config.checkConfigParameter("liquid_type", "CH4");
            const VogelsViscosityConstantsCH4 constants;
            return std::make_unique<
                VogelsLiquidDynamicViscosity<VogelsViscosityConstantsCH4>>(
                constants);
        }
 
        OGS_FATAL(
            "The fluid type {:s} for Vogels model is unavailable.\n"
            "The available fluid types are Water, CO2 and CH4\n",
            fluid_type.data());
    }
    if (type == "WaterViscosityIAPWS")
    {
        config.checkConfigParameter("type", "WaterViscosityIAPWS");
        return std::make_unique<WaterViscosityIAPWS>();
    }
 
    OGS_FATAL(
        "The viscosity type {:s} is unavailable.\n"
        "The available types are \n\tConstant, \n\tLinearPressure "
        "\n\tTemperatureDependent, \n\tVogels\n",
        type.data());
}
 
}  // namespace Fluid
}  // namespace MaterialLib