EclMultiplexerMaterial.hpp File Reference

Implements a multiplexer class that provides all three phase capillary pressure laws used by the ECLipse simulator. More...

#include "EclMultiplexerMaterialParams.hpp"
#include "EclDefaultMaterial.hpp"
#include "EclStone1Material.hpp"
#include "EclStone2Material.hpp"
#include "EclTwoPhaseMaterial.hpp"
#include <opm/common/TimingMacros.hpp>
#include <algorithm>
#include <stdexcept>

Go to the source code of this file.

Classes
class	Opm::EclMultiplexerMaterial< TraitsT, GasOilMaterialLawT, OilWaterMaterialLawT, GasWaterMaterialLawT, ParamsT >
	Implements a multiplexer class that provides all three phase capillary pressure laws used by the ECLipse simulator. More...

Namespaces
namespace	Opm
	This class implements a small container which holds the transmissibility mulitpliers for all the faces in the grid.

Macros
#define	OPM_ECL_MULTIPLEXER_MATERIAL_CALL(codeToCall, onePhaseCode)
#define	STATIC_ASSERT_ECL_MULTIPLEXER_UNLESS_GCC_LT_13   static_assert(false, "Unhandled EclMultiplexerApproach")
#define	OPM_ECL_MULTIPLEXER_MATERIAL_CALL_COMPILETIME(codeToCall, onePhaseCode)
#define	OPM_LOCAL_TEMPLATE_ARGS   ContainerT, FluidState, Args...
#define	OPM_LOCAL_TEMPLATE_ARGS   ContainerT, FluidState, Args...

Functions
void	Opm::doNothing ()

Detailed Description

Implements a multiplexer class that provides all three phase capillary pressure laws used by the ECLipse simulator.

Macro Definition Documentation

OPM_ECL_MULTIPLEXER_MATERIAL_CALL_COMPILETIME

#define OPM_ECL_MULTIPLEXER_MATERIAL_CALL_COMPILETIME	(		codeToCall,
			onePhaseCode )

Value:

    if constexpr (Head::approach == EclMultiplexerApproach::Stone1) {                                                  \
        [[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::Stone1;                   \
        auto& realParams = params.template getRealParams<approach>();                                                  \
        using ActualLaw = Stone1Material;                                                                              \
        codeToCall;                                                                                                    \
    } else if constexpr (Head::approach == EclMultiplexerApproach::Stone2) {                                           \
        [[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::Stone2;                   \
        auto& realParams = params.template getRealParams<approach>();                                                  \
        using ActualLaw = Stone2Material;                                                                              \
        codeToCall;                                                                                                    \
    } else if constexpr (Head::approach == EclMultiplexerApproach::Default) {                                          \
        [[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::Default;                  \
        auto& realParams = params.template getRealParams<approach>();                                                  \
        using ActualLaw = DefaultMaterial;                                                                             \
        codeToCall;                                                                                                    \
    } else if constexpr (Head::approach == EclMultiplexerApproach::TwoPhase) {                                         \
        [[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::TwoPhase;                 \
        auto& realParams = params.template getRealParams<approach>();                                                  \
        using ActualLaw = TwoPhaseMaterial;                                                                            \
        codeToCall;                                                                                                    \
    } else if constexpr (Head::approach == EclMultiplexerApproach::OnePhase) {                                         \
        [[maybe_unused]] constexpr EclMultiplexerApproach approach = EclMultiplexerApproach::OnePhase;                 \
        onePhaseCode;                                                                                                  \
    } else {                                                                                                           \
        STATIC_ASSERT_ECL_MULTIPLEXER_UNLESS_GCC_LT_13;                                                                \
    }