CreateFluidDensityModel.cpp

Go to the documentation of this file.

 
#include "CreateFluidDensityModel.h"
 
#include <array>
 
#include "BaseLib/ConfigTree.h"
#include "BaseLib/Error.h"
#include "IdealGasLaw.h"
#include "LinearConcentrationAndPressureDependentDensity.h"
#include "LinearConcentrationDependentDensity.h"
#include "LinearTemperatureDependentDensity.h"
#include "LiquidDensity.h"
#include "MaterialLib/Fluid/ConstantFluidProperty.h"
 
namespace MaterialLib
{
namespace Fluid
{
static std::unique_ptr<FluidProperty> createLiquidDensity(
    BaseLib::ConfigTree const& config)
{
    config.checkConfigParameter("type", "LiquidDensity");
 
    const auto beta = config.getConfigParameter<double>("beta");
    const auto rho0 = config.getConfigParameter<double>("rho0");
    const auto T0 = config.getConfigParameter<double>("temperature0");
    const auto p0 = config.getConfigParameter<double>("p0");
    const auto E = config.getConfigParameter<double>("bulk_modulus");
    return std::make_unique<LiquidDensity>(beta, rho0, T0, p0, E);
}
 
static std::unique_ptr<FluidProperty> createLinearTemperatureDependentDensity(
    BaseLib::ConfigTree const& config)
{
    config.checkConfigParameter("type", "TemperatureDependent");
 
    const auto rho0 = config.getConfigParameter<double>("rho0");
    const auto T0 = config.getConfigParameter<double>("temperature0");
    const auto beta = config.getConfigParameter<double>("beta");
    return std::make_unique<LinearTemperatureDependentDensity>(rho0, T0, beta);
}
 
static std::unique_ptr<FluidProperty> createLinearConcentrationDependentDensity(
    BaseLib::ConfigTree const& config)
{
    config.checkConfigParameter("type", "ConcentrationDependent");
 
    const auto reference_density =
        config.getConfigParameter<double>("reference_density");
    const auto reference_concentration =
        config.getConfigParameter<double>("reference_concentration");
    const auto fluid_density_difference_ratio =
        config.getConfigParameter<double>("fluid_density_difference_ratio");
    return std::make_unique<LinearConcentrationDependentDensity>(
        reference_density,
        reference_concentration,
        fluid_density_difference_ratio);
}
static std::unique_ptr<FluidProperty>
createLinearConcentrationAndPressureDependentDensity(
    BaseLib::ConfigTree const& config)
{
    config.checkConfigParameter("type", "ConcentrationAndPressureDependent");
 
    const auto reference_density =
        config.getConfigParameter<double>("reference_density");
    const auto reference_concentration =
        config.getConfigParameter<double>("reference_concentration");
    const auto fluid_density_concentration_difference_ratio =
        config.getConfigParameter<double>(
            "fluid_density_concentration_difference_ratio");
    const auto reference_pressure =
        config.getConfigParameter<double>("reference_pressure");
    const auto fluid_density_pressure_difference_ratio =
        config.getConfigParameter<double>(
            "fluid_density_pressure_difference_ratio");
    return std::make_unique<LinearConcentrationAndPressureDependentDensity>(
        reference_density,
        reference_concentration,
        fluid_density_concentration_difference_ratio,
        reference_pressure,
        fluid_density_pressure_difference_ratio);
}
 
std::unique_ptr<FluidProperty> createFluidDensityModel(
    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 == "LiquidDensity")
    {
        return createLiquidDensity(config);
    }
    if (type == "TemperatureDependent")
    {
        return createLinearTemperatureDependentDensity(config);
    }
    if (type == "ConcentrationDependent")
    {
        return createLinearConcentrationDependentDensity(config);
    }
    if (type == "ConcentrationAndPressureDependent")
    {
        return createLinearConcentrationAndPressureDependentDensity(config);
    }
    if (type == "IdealGasLaw")
    {
        config.checkConfigParameter("type", "IdealGasLaw");
        return std::make_unique<IdealGasLaw>(
            config.getConfigParameter<double>("molar_mass"));
    }
 
    OGS_FATAL(
        "The density type {:s} is unavailable.\n"
        "The available types are: \n\tConstant, \n\tLiquidDensity, "
        "\n\tTemperatureDependent, \n\tIdealGasLaw."
        "\n\tWaterDensityIAPWSIF97Region1\n",
        type.data());
}
 
}  // namespace Fluid
}  // namespace MaterialLib