MaterialLib::PorousMedium Namespace Reference

Classes
class	DupuitPermeability
class	Permeability
class	Porosity
class	PorousMediaProperties
class	ConstantStorage
class	Storage
class	BrooksCoreyCapillaryPressureSaturation
	Brooks-Corey capillary pressure saturation model. More...
class	CapillaryPressureSaturation
	Base class of capillary pressure models. More...
class	CapillaryPressureSaturationCurve
class	VanGenuchtenCapillaryPressureSaturation
	van Genuchten water retention model More...
class	NonWettingPhaseBrooksCoreyOilGas
	BrooksCorey oil-gas model: non-wetting phase. More...
class	NonWettingPhaseVanGenuchten
	van Genuchten model: non-wetting phase More...
class	RelativePermeability
	Base class of relative permeability models. More...
class	RelativePermeabilityCurve
class	WettingPhaseBrooksCoreyOilGas
	BrooksCorey oil-gas model: wetting phase. More...
class	WettingPhaseVanGenuchten
	van Genuchten model model: wetting phase More...

Functions
PorousMediaProperties	createPorousMediaProperties (MeshLib::Mesh &mesh, BaseLib::ConfigTree const &configs, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters)
std::unique_ptr< Permeability >	createPermeabilityModel (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters)
std::unique_ptr< Porosity >	createPorosityModel (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &parameters)
std::unique_ptr< Storage >	createStorageModel (BaseLib::ConfigTree const &config)
static std::unique_ptr< CapillaryPressureSaturation >	createBrooksCorey (BaseLib::ConfigTree const &config)
static std::unique_ptr< CapillaryPressureSaturation >	createVanGenuchten (BaseLib::ConfigTree const &config)
std::unique_ptr< CapillaryPressureSaturation >	createCapillaryPressureModel (BaseLib::ConfigTree const &config)
std::unique_ptr< RelativePermeability >	createWettingPhaseVanGenuchten (BaseLib::ConfigTree const &config)
std::unique_ptr< RelativePermeability >	createNonWettingPhaseVanGenuchten (BaseLib::ConfigTree const &config)
std::unique_ptr< RelativePermeability >	createWettingPhaseBrooksCoreyOilGas (BaseLib::ConfigTree const &config)
std::unique_ptr< RelativePermeability >	createNonWettingPhaseBrooksCoreyOilGas (BaseLib::ConfigTree const &config)
std::unique_ptr< RelativePermeability >	createRelativePermeabilityModel (BaseLib::ConfigTree const &config)

Function Documentation

createBrooksCorey()

static std::unique_ptr<CapillaryPressureSaturation> MaterialLib::PorousMedium::createBrooksCorey ( BaseLib::ConfigTree const &  config )

static

Parameters

config

ConfigTree object which contains the input data including <type>BrooksCorey</type> and it has a tag of <capillary_pressure>

Input File Parameter:

material__porous_medium__capillary_pressure__type

Input File Parameter:

material__porous_medium__capillary_pressure__BrooksCorey__pd

Input File Parameter:

material__porous_medium__capillary_pressure__BrooksCorey__sr

Input File Parameter:

material__porous_medium__capillary_pressure__BrooksCorey__sg_r

Input File Parameter:

material__porous_medium__capillary_pressure__BrooksCorey__smax

Input File Parameter:

material__porous_medium__capillary_pressure__BrooksCorey__m

Input File Parameter:

material__porous_medium__capillary_pressure__BrooksCorey__pc_max

Definition at line 33 of file CreateCapillaryPressureModel.cpp.

{
    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);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), and OGS_FATAL.

Referenced by createCapillaryPressureModel().

createCapillaryPressureModel()

std::unique_ptr< CapillaryPressureSaturation > MaterialLib::PorousMedium::createCapillaryPressureModel

(

BaseLib::ConfigTree const &

config

)

Create a capillary pressure model

Parameters

config

ConfigTree object has a tag of <capillary_pressure>

Input File Parameter:

material__porous_medium__capillary_pressure__type

Input File Parameter:

material__porous_medium__capillary_pressure__type

Input File Parameter:

material__porous_medium__capillary_pressure__Curve__curve

Definition at line 128 of file CreateCapillaryPressureModel.cpp.

{
    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());
}

References BaseLib::ConfigTree::checkConfigParameter(), createBrooksCorey(), MathLib::createPiecewiseLinearCurve(), createVanGenuchten(), BaseLib::ConfigTree::getConfigSubtree(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by MaterialLib::TwoPhaseFlowWithPP::createTwoPhaseFlowMaterialProperties(), and ProcessLib::TwoPhaseFlowWithPrho::createTwoPhaseFlowPrhoMaterialProperties().

createNonWettingPhaseBrooksCoreyOilGas()

std::unique_ptr<RelativePermeability> MaterialLib::PorousMedium::createNonWettingPhaseBrooksCoreyOilGas

(

BaseLib::ConfigTree const &

config

)

Parameters

config

ConfigTree object which contains the input data including <type>NonWettingPhaseBrooksCoreyOilGas</type> and it has a tag of <relative_permeability>

Input File Parameter:

material__porous_medium__relative_permeability__type

Input File Parameter:

material__porous_medium__relative_permeability__NonWettingPhaseBrooksCoreyOilGas__sr

Input File Parameter:

material__porous_medium__relative_permeability__NonWettingPhaseBrooksCoreyOilGas__smax

Input File Parameter:

material__porous_medium__relative_permeability__NonWettingPhaseBrooksCoreyOilGas__m

Input File Parameter:

material__porous_medium__relative_permeability__NonWettingPhaseBrooksCoreyOilGas__krel_min

Definition at line 136 of file CreateRelativePermeabilityModel.cpp.

{
    config.checkConfigParameter("type", "NonWettingPhaseBrooksCoreyOilGas");
 
    const auto Sr = config.getConfigParameter<double>("sr");
 
    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 NonWettingPhaseBrooksCoreyOilGas\n"
            "relative permeability model, m, must not be smaller than 1");
    }
 
    const auto krel_min = config.getConfigParameter<double>("krel_min");
 
    return std::make_unique<NonWettingPhaseBrooksCoreyOilGas>(
        Sr, Smax, m, krel_min);
}

References BaseLib::ConfigTree::checkConfigParameter(), BaseLib::ConfigTree::getConfigParameter(), and OGS_FATAL.

Referenced by createRelativePermeabilityModel().

createNonWettingPhaseVanGenuchten()

std::unique_ptr<RelativePermeability> MaterialLib::PorousMedium::createNonWettingPhaseVanGenuchten

(

BaseLib::ConfigTree const &

config

)

Parameters

config

ConfigTree object which contains the input data including <type>NonWettingPhaseVanGenuchten</type> and it has a tag of <relative_permeability>

Input File Parameter:

material__porous_medium__relative_permeability__type

Input File Parameter:

material__porous_medium__relative_permeability__NonWettingPhaseVanGenuchten__sr

Input File Parameter:

material__porous_medium__relative_permeability__NonWettingPhaseVanGenuchten__smax

Input File Parameter:

material__porous_medium__relative_permeability__NonWettingPhaseVanGenuchten__m

Input File Parameter:

material__porous_medium__relative_permeability__NonWettingPhaseVanGenuchten__krel_min

Definition at line 71 of file CreateRelativePermeabilityModel.cpp.

{
    config.checkConfigParameter("type", "NonWettingPhaseVanGenuchten");
 
    const auto Sr = config.getConfigParameter<double>("sr");
 
    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 NonWettingPhaseVanGenuchten relative\n"
            " permeability model, m, must be in an interval of [0, 1]");
    }
 
    const auto krel_min = config.getConfigParameter<double>("krel_min");
 
    return std::make_unique<NonWettingPhaseVanGenuchten>(Sr, Smax, m, krel_min);
}

References BaseLib::ConfigTree::checkConfigParameter(), BaseLib::ConfigTree::getConfigParameter(), and OGS_FATAL.

Referenced by createRelativePermeabilityModel().

createPermeabilityModel()

std::unique_ptr< Permeability > MaterialLib::PorousMedium::createPermeabilityModel	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters
	)

Create a porosity model

Parameters

config	ConfigTree object has a tag of <permeability> that describes the permeability relationsship and contains the name of the parameter
parameters	a vector containing the available parameters

Input File Parameter:

material__porous_medium__permeability__type

Input File Parameter:

material__porous_medium__permeability__permeability_tensor_entries

Input File Parameter:

material__porous_medium__permeability__permeability_tensor_entries

Definition at line 29 of file createPermeabilityModel.cpp.

{
    auto const type = config.getConfigParameter<std::string>("type");
 
    if (type == "Constant")
    {
        auto const& permeability_parameter = ParameterLib::findParameter<
            double>(
            config,
            "permeability_tensor_entries", parameters, 0);
 
        int dimension = static_cast<int>(
            std::sqrt(permeability_parameter.getNumberOfGlobalComponents()));
        if (permeability_parameter.getNumberOfGlobalComponents() !=
            dimension * dimension)
        {
            OGS_FATAL(
                "The given parameter has {:d} components, but the permeability "
                "tensor is defined for a {:d} dimensional problem.",
                permeability_parameter.getNumberOfGlobalComponents(),
                dimension);
        }
 
        return std::make_unique<Permeability>(permeability_parameter,
                                              dimension);
    }
 
    if (type == "Dupuit")
    {
        auto const& permeability_parameter = ParameterLib::findParameter<
            double>(
            config,
            "permeability_tensor_entries", parameters, 0);
 
        int dimension = static_cast<int>(
            std::sqrt(permeability_parameter.getNumberOfGlobalComponents()));
        if (permeability_parameter.getNumberOfGlobalComponents() !=
            dimension * dimension)
        {
            OGS_FATAL(
                "The given parameter has {:d} components, but the permeability "
                "tensor is defined for a {:d} dimensional problem.",
                permeability_parameter.getNumberOfGlobalComponents(),
                dimension);
        }
 
        return std::make_unique<DupuitPermeability>(permeability_parameter,
                                                    dimension);
    }
    OGS_FATAL("The permeability type '{:s}' is unavailable.\n",
              "The available types are \n\tConstant.",
              type.data());
}

References ParameterLib::findParameter(), BaseLib::ConfigTree::getConfigParameter(), and OGS_FATAL.

Referenced by createPorousMediaProperties(), MaterialLib::TwoPhaseFlowWithPP::createTwoPhaseFlowMaterialProperties(), and ProcessLib::TwoPhaseFlowWithPrho::createTwoPhaseFlowPrhoMaterialProperties().

createPorosityModel()

std::unique_ptr< Porosity > MaterialLib::PorousMedium::createPorosityModel	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters
	)

Create a porosity model

Parameters

config	ConfigTree object has a tag of <porosity> that describes the porosity relationsship and contains the name of the parameter
parameters	a vector containing the available parameters

Input File Parameter:

material__porous_medium__porosity__type

Input File Parameter:

material__porous_medium__porosity__porosity_parameter

Definition at line 24 of file createPorosityModel.cpp.

{
    auto const type = config.getConfigParameter<std::string>("type");
 
    if (type == "Constant")
    {
        auto const& constant_porosity = ParameterLib::findParameter<double>(
            config,
            "porosity_parameter", parameters, 1);
 
        return std::make_unique<Porosity>(constant_porosity);
    }
 
    OGS_FATAL("The porosity type {:s} is unavailable.\n",
              "The available type is Constant.",
              type.data());
}

References BaseLib::ConfigTree::getConfigParameter(), and OGS_FATAL.

Referenced by createPorousMediaProperties(), MaterialLib::TwoPhaseFlowWithPP::createTwoPhaseFlowMaterialProperties(), and ProcessLib::TwoPhaseFlowWithPrho::createTwoPhaseFlowPrhoMaterialProperties().

createPorousMediaProperties()

PorousMediaProperties MaterialLib::PorousMedium::createPorousMediaProperties	(	MeshLib::Mesh &	mesh,
		BaseLib::ConfigTree const &	configs,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase >> const &	parameters
	)

Input File Parameter:

material__porous_medium__porous_medium

Input File Parameter:

material__porous_medium__porous_medium

Input File Parameter:

material__porous_medium__porous_medium__id

Input File Parameter:

material__porous_medium__porous_medium__porosity

Input File Parameter:

material__porous_medium__porous_medium__permeability

Input File Parameter:

material__porous_medium__porous_medium__storage

Definition at line 23 of file CreatePorousMediaProperties.cpp.

{
    DBUG("Create PorousMediaProperties.");
 
    auto const& porous_medium_configs =
        configs.getConfigSubtree("porous_medium");
 
    std::vector<std::unique_ptr<MaterialLib::PorousMedium::Permeability>>
        intrinsic_permeability_models;
    std::vector<std::unique_ptr<MaterialLib::PorousMedium::Porosity>>
        porosity_models;
    std::vector<std::unique_ptr<MaterialLib::PorousMedium::Storage>>
        storage_models;
 
    std::vector<int> mat_ids;
    for (auto const& porous_medium_config :
         porous_medium_configs.getConfigSubtreeList("porous_medium"))
    {
        auto const id = porous_medium_config.getConfigAttribute<int>("id");
        mat_ids.push_back(id);
 
        auto const& porosity_config =
            porous_medium_config.getConfigSubtree("porosity");
        porosity_models.emplace_back(
            MaterialLib::PorousMedium::createPorosityModel(porosity_config,
                                                           parameters));
 
        // Configuration for the intrinsic permeability (only one scalar per
        // element, i.e., the isotropic case is handled at the moment)
        auto const& permeability_config =
            porous_medium_config.getConfigSubtree("permeability");
        intrinsic_permeability_models.emplace_back(
            MaterialLib::PorousMedium::createPermeabilityModel(
                permeability_config, parameters));
 
        // Configuration for the specific storage.
        auto const& storage_config =
            porous_medium_config.getConfigSubtree("storage");
        storage_models.emplace_back(
            MaterialLib::PorousMedium::createStorageModel(storage_config));
    }
 
    BaseLib::reorderVector(intrinsic_permeability_models, mat_ids);
    BaseLib::reorderVector(porosity_models, mat_ids);
    BaseLib::reorderVector(storage_models, mat_ids);
 
    auto const material_ids = materialIDs(mesh);
    int const max_material_id =
        !material_ids
            ? 0
            : *std::max_element(begin(*material_ids), end(*material_ids));
 
    if (max_material_id > static_cast<int>(mat_ids.size() - 1))
    {
        OGS_FATAL(
            "The maximum value of MaterialIDs in mesh is {:d}. As the "
            "given number of porous media definitions in the project file is "
            "{:d}, the maximum value of MaterialIDs in mesh must be {:d} "
            "(index starts with zero).",
            max_material_id, mat_ids.size(), max_material_id - 1);
    }
 
    if (max_material_id < static_cast<int>(mat_ids.size() - 1))
        WARN(
            "There are {:d} porous medium definitions in the project file but "
            "only {:d} different values in the MaterialIDs vector/data_array "
            "in the mesh.",
            mat_ids.size(), max_material_id - 1);
 
    if (mat_ids.back() != static_cast<int>(mat_ids.size()) - 1)
    {
        OGS_FATAL(
            "The ids in the porous media definitions in the project file have "
            "to be sequential, starting with the id zero.");
    }
 
    return PorousMediaProperties{std::move(porosity_models),
                                 std::move(intrinsic_permeability_models),
                                 std::move(storage_models), material_ids};
}

References createPermeabilityModel(), createPorosityModel(), createStorageModel(), DBUG(), BaseLib::ConfigTree::getConfigAttribute(), BaseLib::ConfigTree::getConfigSubtree(), MeshLib::materialIDs(), OGS_FATAL, BaseLib::reorderVector(), and WARN().

createRelativePermeabilityModel()

std::unique_ptr< RelativePermeability > MaterialLib::PorousMedium::createRelativePermeabilityModel

(

BaseLib::ConfigTree const &

config

)

Create a capillary pressure model

Parameters

config

ConfigTree object has a tag of <relative_permeability>

Input File Parameter:

material__porous_medium__relative_permeability__type

Input File Parameter:

material__porous_medium__relative_permeability__type

Input File Parameter:

material__porous_medium__relative_permeability__Curve__curve

Definition at line 164 of file CreateRelativePermeabilityModel.cpp.

{
    auto const type = config.peekConfigParameter<std::string>("type");
 
    if (type == "WettingPhaseVanGenuchten")
    {
        return createWettingPhaseVanGenuchten(config);
    }
    if (type == "NonWettingPhaseVanGenuchten")
    {
        return createNonWettingPhaseVanGenuchten(config);
    }
    if (type == "WettingPhaseBrooksCoreyOilGas")
    {
        return createWettingPhaseBrooksCoreyOilGas(config);
    }
    if (type == "NonWettingPhaseBrooksCoreyOilGas")
    {
        return createNonWettingPhaseBrooksCoreyOilGas(config);
    }
    if (type == "Curve")
    {
        config.checkConfigParameter("type", "Curve");
 
        auto const& curve_config = config.getConfigSubtree("curve");
 
        auto curve = MathLib::createPiecewiseLinearCurve<
            MathLib ::PiecewiseLinearInterpolation>(curve_config);
        return std::make_unique<RelativePermeabilityCurve>(std::move(curve));
    }
 
    OGS_FATAL(
        "The relative permeability model {:s} is unavailable.\n"
        "The available models are:"
        "\n\tWettingPhaseVanGenuchten,"
        "\n\tNonWettingPhaseVanGenuchten,"
        "\n\tWettingPhaseBrooksCoreyOilGas,"
        "\n\tNonWettingPhaseBrooksCoreyOilGas,",
        "\n\tCurve.\n",
        type.data());
}

References BaseLib::ConfigTree::checkConfigParameter(), createNonWettingPhaseBrooksCoreyOilGas(), createNonWettingPhaseVanGenuchten(), MathLib::createPiecewiseLinearCurve(), createWettingPhaseBrooksCoreyOilGas(), createWettingPhaseVanGenuchten(), BaseLib::ConfigTree::getConfigSubtree(), OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

Referenced by MaterialLib::TwoPhaseFlowWithPP::createTwoPhaseFlowMaterialProperties(), and ProcessLib::TwoPhaseFlowWithPrho::createTwoPhaseFlowPrhoMaterialProperties().

createStorageModel()

std::unique_ptr< Storage > MaterialLib::PorousMedium::createStorageModel

(

BaseLib::ConfigTree const &

config

)

Create a storage model

Parameters

config

ConfigTree object has a tag of <storage>

Input File Parameter:

material__porous_medium__storage__type

Input File Parameter:

material__porous_medium__storage__Constant__value

Definition at line 24 of file createStorageModel.cpp.

{
    auto const type = config.getConfigParameter<std::string>("type");
 
    if (type == "Constant")
    {
        return std::make_unique<ConstantStorage>(
            config.getConfigParameter<double>("value"));
    }
 
    OGS_FATAL("The storage type {:s} is unavailable.\n", type.data(),
              "The available type is Constant.");
}

References BaseLib::ConfigTree::getConfigParameter(), and OGS_FATAL.

Referenced by createPorousMediaProperties(), MaterialLib::TwoPhaseFlowWithPP::createTwoPhaseFlowMaterialProperties(), and ProcessLib::TwoPhaseFlowWithPrho::createTwoPhaseFlowPrhoMaterialProperties().

createVanGenuchten()

static std::unique_ptr<CapillaryPressureSaturation> MaterialLib::PorousMedium::createVanGenuchten ( BaseLib::ConfigTree const &  config )

static

Parameters

config

ConfigTree object which contains the input data including <type>vanGenuchten</type> and it has a tag of <capillary_pressure>

Input File Parameter:

material__porous_medium__capillary_pressure__type

Input File Parameter:

material__porous_medium__capillary_pressure__vanGenuchten__pd

Input File Parameter:

material__porous_medium__capillary_pressure__vanGenuchten__sr

Input File Parameter:

material__porous_medium__capillary_pressure__vanGenuchten__sg_r

Input File Parameter:

material__porous_medium__capillary_pressure__vanGenuchten__smax

Input File Parameter:

material__porous_medium__capillary_pressure__vanGenuchten__m

Input File Parameter:

material__porous_medium__capillary_pressure__vanGenuchten__pc_max

Input File Parameter:

material__porous_medium__capillary_pressure__vanGenuchten__has_regularized

Definition at line 78 of file CreateCapillaryPressureModel.cpp.

{
    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);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigParameterOptional(), and OGS_FATAL.

Referenced by createCapillaryPressureModel().

createWettingPhaseBrooksCoreyOilGas()

std::unique_ptr<RelativePermeability> MaterialLib::PorousMedium::createWettingPhaseBrooksCoreyOilGas

(

BaseLib::ConfigTree const &

config

)

Parameters

config

ConfigTree object which contains the input data including <type>WettingPhaseBrooksCoreyOilGas</type> and it has a tag of <relative_permeability>

Input File Parameter:

material__porous_medium__relative_permeability__type

Input File Parameter:

material__porous_medium__relative_permeability__WettingPhaseBrooksCoreyOilGas__sr

Input File Parameter:

material__porous_medium__relative_permeability__WettingPhaseBrooksCoreyOilGas__smax

Input File Parameter:

material__porous_medium__relative_permeability__WettingPhaseBrooksCoreyOilGas__m

Input File Parameter:

material__porous_medium__relative_permeability__WettingPhaseBrooksCoreyOilGas__krel_min

Definition at line 103 of file CreateRelativePermeabilityModel.cpp.

{
    config.checkConfigParameter("type", "WettingPhaseBrooksCoreyOilGas");
 
    const auto Sr = config.getConfigParameter<double>("sr");
 
    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 WettingPhaseBrooksCoreyOilGas\n"
            "relative permeability model, m, must not be smaller than 1");
    }
 
    const auto krel_min = config.getConfigParameter<double>("krel_min");
 
    return std::make_unique<WettingPhaseBrooksCoreyOilGas>(
        Sr, Smax, m, krel_min);
}

References BaseLib::ConfigTree::checkConfigParameter(), BaseLib::ConfigTree::getConfigParameter(), and OGS_FATAL.

Referenced by createRelativePermeabilityModel().

createWettingPhaseVanGenuchten()

std::unique_ptr<RelativePermeability> MaterialLib::PorousMedium::createWettingPhaseVanGenuchten

(

BaseLib::ConfigTree const &

config

)

Parameters

config

ConfigTree object which contains the input data including <type>WettingPhaseVanGenuchten</type> and it has a tag of <relative_permeability>

Input File Parameter:

material__porous_medium__relative_permeability__type

Input File Parameter:

material__porous_medium__relative_permeability__WettingPhaseVanGenuchten__sr

Input File Parameter:

material__porous_medium__relative_permeability__WettingPhaseVanGenuchten__smax

Input File Parameter:

material__porous_medium__relative_permeability__WettingPhaseVanGenuchten__m

Input File Parameter:

material__porous_medium__relative_permeability__WettingPhaseVanGenuchten__krel_min

Definition at line 40 of file CreateRelativePermeabilityModel.cpp.

{
    config.checkConfigParameter("type", "WettingPhaseVanGenuchten");
 
    const auto Sr = config.getConfigParameter<double>("sr");
 
    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 WettingPhaseVanGenuchten relative\n"
            " permeability model, m, must be in an interval of [0, 1]");
    }
    const auto krel_min = config.getConfigParameter<double>("krel_min");
 
    return std::make_unique<WettingPhaseVanGenuchten>(Sr, Smax, m, krel_min);
}

References BaseLib::ConfigTree::checkConfigParameter(), BaseLib::ConfigTree::getConfigParameter(), and OGS_FATAL.

Referenced by createRelativePermeabilityModel().