CreateCapillaryPressureModel.cpp

Go to the documentation of this file.

 
#include "CreateCapillaryPressureModel.h"
 
#include "BaseLib/ConfigTree.h"
#include "BaseLib/Error.h"
#include "BrooksCoreyCapillaryPressureSaturation.h"
#include "CapillaryPressureSaturation.h"
#include "CapillaryPressureSaturationCurve.h"
#include "MathLib/Curve/CreatePiecewiseLinearCurve.h"
#include "MathLib/Curve/PiecewiseLinearMonotonicCurve.h"
#include "VanGenuchtenCapillaryPressureSaturation.h"
 
namespace MaterialLib
{
namespace PorousMedium
{
static std::unique_ptr<CapillaryPressureSaturation> createBrooksCorey(
    BaseLib::ConfigTree const& config)
{
    config.checkConfigParameter("type", "BrooksCorey");
 
    const auto pd = config.getConfigParameter<double>("pd");
 
    const auto Sr = config.getConfigParameter<double>("sr");
 
    double Sg_r = 0.0;
    if (auto const Sg_r_ptr = config.getConfigParameterOptional<double>("sg_r"))
    {
        DBUG(
            "Using value {:g} for nonwetting phase residual saturation in "
            "capillary pressure model.",
            (*Sg_r_ptr));
        Sg_r = *Sg_r_ptr;
    }
    const auto Smax = config.getConfigParameter<double>("smax");
 
    const auto m = config.getConfigParameter<double>("m");
    if (m < 1.0)  // m >= 1
    {
        OGS_FATAL(
            "The exponent parameter of BrooksCorey capillary pressure "
            "saturation model, m, must not be smaller than 1");
    }
    const auto Pc_max = config.getConfigParameter<double>("pc_max");
 
    return std::make_unique<BrooksCoreyCapillaryPressureSaturation>(
        pd, Sr, Sg_r, Smax, m, Pc_max);
}
 
static std::unique_ptr<CapillaryPressureSaturation> createVanGenuchten(
    BaseLib::ConfigTree const& config)
{
    config.checkConfigParameter("type", "vanGenuchten");
 
    const auto pd = config.getConfigParameter<double>("pd");
 
    const auto Sr = config.getConfigParameter<double>("sr");
 
    double Sg_r = 0.0;
    if (auto const Sg_r_ptr = config.getConfigParameterOptional<double>("sg_r"))
    {
        DBUG(
            "Using value {:g} for nonwetting phase residual saturation in "
            "capillary pressure model.",
            (*Sg_r_ptr));
        Sg_r = *Sg_r_ptr;
    }
 
    const auto Smax = config.getConfigParameter<double>("smax");
 
    const auto m = config.getConfigParameter<double>("m");
    if (m < 0. || m > 1.0)
    {
        OGS_FATAL(
            "The exponent parameter of van Genuchten capillary pressure "
            "saturation model, m, must be in an interval of [0, 1]");
    }
    const auto Pc_max = config.getConfigParameter<double>("pc_max");
 
    bool has_regularized = false;
    if (auto const has_regularized_conf =
        config.getConfigParameterOptional<bool>("has_regularized"))
    {
        DBUG("capillary pressure model: {:s}",
             (*has_regularized_conf) ? "true" : "false");
        has_regularized = *has_regularized_conf;
    }
    return std::make_unique<VanGenuchtenCapillaryPressureSaturation>(
        pd, Sr, Sg_r, Smax, m, Pc_max, has_regularized);
}
 
std::unique_ptr<CapillaryPressureSaturation> createCapillaryPressureModel(
    BaseLib::ConfigTree const& config)
{
    auto const type = config.peekConfigParameter<std::string>("type");
 
    if (type == "BrooksCorey")
    {
        return createBrooksCorey(config);
    }
    if (type == "vanGenuchten")
    {
        return createVanGenuchten(config);
    }
    if (type == "Curve")
    {
        config.checkConfigParameter("type", "Curve");
 
        auto const& curve_config = config.getConfigSubtree("curve");
 
        auto curve = MathLib::createPiecewiseLinearCurve<
            MathLib::PiecewiseLinearMonotonicCurve>(curve_config);
 
        return std::make_unique<CapillaryPressureSaturationCurve>(
            std::move(curve));
    }
 
    OGS_FATAL(
        "The capillary pressure saturation models {:s} are unavailable.\nThe "
        "available types are: \n\tBrooksCorey, \n\tvanGenuchten,",
        "\n\tCurve.\n",
        type.data());
}
 
}  // namespace PorousMedium
}  // namespace MaterialLib