EclMultiplexerMaterial.hpp

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*
  Copyright (C) 2015 by Andreas Lauser

  This file is part of the Open Porous Media project (OPM).

  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 2 of the License, or
  (at your option) any later version.

  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef OPM_ECL_MULTIPLEXER_MATERIAL_HPP
#define OPM_ECL_MULTIPLEXER_MATERIAL_HPP

#include "EclMultiplexerMaterialParams.hpp"
#include "EclDefaultMaterial.hpp"
#include "EclStone1Material.hpp"
#include "EclStone2Material.hpp"
#include "EclTwoPhaseMaterial.hpp"

#include <opm/material/common/Valgrind.hpp>
#include <opm/material/common/MathToolbox.hpp>
#include <opm/common/Exceptions.hpp>
#include <opm/common/ErrorMacros.hpp>

#include <algorithm>

namespace Opm {

template <class TraitsT,
          class GasOilMaterialLawT,
          class OilWaterMaterialLawT,
          class ParamsT = EclMultiplexerMaterialParams<TraitsT,
                                                       GasOilMaterialLawT,
                                                       OilWaterMaterialLawT> >
class EclMultiplexerMaterial : public TraitsT
{
public:
    typedef GasOilMaterialLawT GasOilMaterialLaw;
    typedef OilWaterMaterialLawT OilWaterMaterialLaw;

    typedef Opm::EclStone1Material<TraitsT, GasOilMaterialLaw, OilWaterMaterialLaw> Stone1Material;
    typedef Opm::EclStone2Material<TraitsT, GasOilMaterialLaw, OilWaterMaterialLaw> Stone2Material;
    typedef Opm::EclDefaultMaterial<TraitsT, GasOilMaterialLaw, OilWaterMaterialLaw> DefaultMaterial;
    typedef Opm::EclTwoPhaseMaterial<TraitsT, GasOilMaterialLaw, OilWaterMaterialLaw> TwoPhaseMaterial;

    // some safety checks
    static_assert(TraitsT::numPhases == 3,
                  "The number of phases considered by this capillary pressure "
                  "law is always three!");
    static_assert(GasOilMaterialLaw::numPhases == 2,
                  "The number of phases considered by the gas-oil capillary "
                  "pressure law must be two!");
    static_assert(OilWaterMaterialLaw::numPhases == 2,
                  "The number of phases considered by the oil-water capillary "
                  "pressure law must be two!");
    static_assert(std::is_same<typename GasOilMaterialLaw::Scalar,
                               typename OilWaterMaterialLaw::Scalar>::value,
                  "The two two-phase capillary pressure laws must use the same "
                  "type of floating point values.");

    typedef TraitsT Traits;
    typedef ParamsT Params;
    typedef typename Traits::Scalar Scalar;

    static const int numPhases = 3;
    static const int waterPhaseIdx = Traits::wettingPhaseIdx;
    static const int oilPhaseIdx = Traits::nonWettingPhaseIdx;
    static const int gasPhaseIdx = Traits::gasPhaseIdx;

    static const bool implementsTwoPhaseApi = false;

    static const bool implementsTwoPhaseSatApi = false;

    static const bool isSaturationDependent = true;

    static const bool isPressureDependent = false;

    static const bool isTemperatureDependent = false;

    static const bool isCompositionDependent = false;

    template <class ContainerT, class FluidState>
    static void capillaryPressures(ContainerT &values,
                                   const Params &params,
                                   const FluidState &fluidState)
    {
        switch (params.approach()) {
        case EclStone1Approach:
            Stone1Material::capillaryPressures(values,
                                               params.template getRealParams<EclStone1Approach>(),
                                               fluidState);
            break;

        case EclStone2Approach:
            Stone2Material::capillaryPressures(values,
                                               params.template getRealParams<EclStone2Approach>(),
                                               fluidState);
            break;

        case EclDefaultApproach:
            DefaultMaterial::capillaryPressures(values,
                                                params.template getRealParams<EclDefaultApproach>(),
                                                fluidState);
            break;

        case EclTwoPhaseApproach:
            TwoPhaseMaterial::capillaryPressures(values,
                                                 params.template getRealParams<EclTwoPhaseApproach>(),
                                                 fluidState);
            break;
        }
    }

    template <class FluidState, class Evaluation = typename FluidState::Scalar>
    static Evaluation pcgn(const Params& /* params */,
                           const FluidState& /* fs */)
    {
        OPM_THROW(std::logic_error, "Not implemented: pcgn()");
    }

    template <class FluidState, class Evaluation = typename FluidState::Scalar>
    static Evaluation pcnw(const Params& /* params */,
                           const FluidState& /* fs */)
    {
        OPM_THROW(std::logic_error, "Not implemented: pcnw()");
    }

    template <class ContainerT, class FluidState>
    static void saturations(ContainerT& /* values */,
                            const Params& /* params */,
                            const FluidState& /* fs */)
    {
        OPM_THROW(std::logic_error, "Not implemented: saturations()");
    }

    template <class FluidState, class Evaluation = typename FluidState::Scalar>
    static Evaluation Sg(const Params& /* params */,
                         const FluidState& /* fluidState */)
    {
        OPM_THROW(std::logic_error, "Not implemented: Sg()");
    }

    template <class FluidState, class Evaluation = typename FluidState::Scalar>
    static Evaluation Sn(const Params& /* params */,
                         const FluidState& /* fluidState */)
    {
        OPM_THROW(std::logic_error, "Not implemented: Sn()");
    }

    template <class FluidState, class Evaluation = typename FluidState::Scalar>
    static Evaluation Sw(const Params& /* params */,
                         const FluidState& /* fluidState */)
    {
        OPM_THROW(std::logic_error, "Not implemented: Sw()");
    }

    template <class ContainerT, class FluidState>
    static void relativePermeabilities(ContainerT &values,
                                       const Params &params,
                                       const FluidState &fluidState)
    {
        switch (params.approach()) {
        case EclStone1Approach:
            Stone1Material::relativePermeabilities(values,
                                                   params.template getRealParams<EclStone1Approach>(),
                                                   fluidState);
            break;

        case EclStone2Approach:
            Stone2Material::relativePermeabilities(values,
                                                   params.template getRealParams<EclStone2Approach>(),
                                                   fluidState);
            break;

        case EclDefaultApproach:
            DefaultMaterial::relativePermeabilities(values,
                                                    params.template getRealParams<EclDefaultApproach>(),
                                                    fluidState);
            break;

        case EclTwoPhaseApproach:
            TwoPhaseMaterial::relativePermeabilities(values,
                                                     params.template getRealParams<EclTwoPhaseApproach>(),
                                                     fluidState);
            break;
        }
    }

    template <class FluidState, class Evaluation = typename FluidState::Scalar>
    static Evaluation krg(const Params& /* params */,
                          const FluidState& /* fluidState */)
    {
        OPM_THROW(std::logic_error, "Not implemented: krg()");
    }

    template <class FluidState, class Evaluation = typename FluidState::Scalar>
    static Evaluation krw(const Params& /* params */,
                          const FluidState& /* fluidState */)
    {
        OPM_THROW(std::logic_error, "Not implemented: krw()");
    }

    template <class FluidState, class Evaluation = typename FluidState::Scalar>
    static Evaluation krn(const Params& /* params */,
                          const FluidState& /* fluidState */)
    {
        OPM_THROW(std::logic_error, "Not implemented: krn()");
    }


    template <class FluidState>
    static void updateHysteresis(Params &params, const FluidState &fluidState)
    {
        switch (params.approach()) {
        case EclStone1Approach:
            Stone1Material::updateHysteresis(params.template getRealParams<EclStone1Approach>(),
                                             fluidState);
            break;

        case EclStone2Approach:
            Stone2Material::updateHysteresis(params.template getRealParams<EclStone2Approach>(),
                                             fluidState);
            break;

        case EclDefaultApproach:
            DefaultMaterial::updateHysteresis(params.template getRealParams<EclDefaultApproach>(),
                                              fluidState);
            break;

        case EclTwoPhaseApproach:
            TwoPhaseMaterial::updateHysteresis(params.template getRealParams<EclTwoPhaseApproach>(),
                                               fluidState);
            break;
        }
    }
};
} // namespace Opm

#endif