OilPvtMultiplexer.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_OIL_PVT_MULTIPLEXER_HPP
#define OPM_OIL_PVT_MULTIPLEXER_HPP

#include "ConstantCompressibilityOilPvt.hpp"
#include "DeadOilPvt.hpp"
#include "LiveOilPvt.hpp"

namespace Opm {
template <class Scalar>
class GasPvtMultiplexer;

#define OPM_OIL_PVT_MULTIPLEXER_CALL(codeToCall)                        \
    switch (oilPvtApproach_) {                                          \
    case ConstantCompressibilityOilPvt: {                               \
        auto &pvtImpl = getRealOilPvt<ConstantCompressibilityOilPvt>(); \
        codeToCall;                                                     \
        break;                                                          \
    }                                                                   \
    case DeadOilPvt: {                                                  \
        auto &pvtImpl = getRealOilPvt<DeadOilPvt>();                    \
        codeToCall;                                                     \
        break;                                                          \
    }                                                                   \
    case LiveOilPvt: {                                                  \
        auto &pvtImpl = getRealOilPvt<LiveOilPvt>();                    \
        codeToCall;                                                     \
        break;                                                          \
    }                                                                   \
    case NoOilPvt:                                                      \
        OPM_THROW(std::logic_error, "Not implemented: Oil PVT of this deck!"); \
    }

template <class Scalar>
class OilPvtMultiplexer
{
    typedef Opm::GasPvtMultiplexer<Scalar> GasPvtMultiplexer;

public:
    enum OilPvtApproach {
        NoOilPvt,
        LiveOilPvt,
        DeadOilPvt,
        ConstantCompressibilityOilPvt
    };

    OilPvtMultiplexer()
    {
        oilPvtApproach_ = NoOilPvt;
    }

    ~OilPvtMultiplexer()
    {
        switch (oilPvtApproach_) {
        case ConstantCompressibilityOilPvt: {
            delete &getRealOilPvt<ConstantCompressibilityOilPvt>();
            break;
        }
        case DeadOilPvt: {
            delete &getRealOilPvt<DeadOilPvt>();
            break;
        }
        case LiveOilPvt: {
            delete &getRealOilPvt<LiveOilPvt>();
            break;
        }

        case NoOilPvt:
            break;
        }
    }

#if HAVE_OPM_PARSER

    void initFromDeck(DeckConstPtr deck, EclipseStateConstPtr eclState)
    {
        if (deck->hasKeyword("PVCDO"))
            setApproach(ConstantCompressibilityOilPvt);
        else if (deck->hasKeyword("PVDO"))
            setApproach(DeadOilPvt);
        else if (deck->hasKeyword("PVTO"))
            setApproach(LiveOilPvt);

        OPM_OIL_PVT_MULTIPLEXER_CALL(pvtImpl.initFromDeck(deck, eclState));
    }
#endif // HAVE_OPM_PARSER


    void initEnd(const GasPvtMultiplexer *gasPvt)
    { OPM_OIL_PVT_MULTIPLEXER_CALL(pvtImpl.initEnd(gasPvt)); }

    template <class Evaluation>
    Evaluation viscosity(unsigned regionIdx,
                         const Evaluation& temperature,
                         const Evaluation& pressure,
                         const Evaluation& XoG) const
    { OPM_OIL_PVT_MULTIPLEXER_CALL(return pvtImpl.viscosity(regionIdx, temperature, pressure, XoG)); return 0; }

    template <class Evaluation>
    Evaluation formationVolumeFactor(unsigned regionIdx,
                                     const Evaluation& temperature,
                                     const Evaluation& pressure,
                                     const Evaluation& XoG) const
    { OPM_OIL_PVT_MULTIPLEXER_CALL(return pvtImpl.formationVolumeFactor(regionIdx, temperature, pressure, XoG)); return 0; }

    template <class Evaluation>
    Evaluation density(unsigned regionIdx,
                       const Evaluation& temperature,
                       const Evaluation& pressure,
                       const Evaluation& XoG) const
    { OPM_OIL_PVT_MULTIPLEXER_CALL(return pvtImpl.density(regionIdx, temperature, pressure, XoG)); return 0; }

    template <class Evaluation>
    Evaluation fugacityCoefficientOil(unsigned regionIdx,
                                      const Evaluation& temperature,
                                      const Evaluation& pressure) const
    { OPM_OIL_PVT_MULTIPLEXER_CALL(return pvtImpl.fugacityCoefficientOil(regionIdx, temperature, pressure)); return 0; }

    template <class Evaluation>
    Evaluation fugacityCoefficientGas(unsigned regionIdx,
                                      const Evaluation& temperature,
                                      const Evaluation& pressure) const
    { OPM_OIL_PVT_MULTIPLEXER_CALL(return pvtImpl.fugacityCoefficientGas(regionIdx, temperature, pressure)); return 0; }

    template <class Evaluation>
    Evaluation fugacityCoefficientWater(unsigned regionIdx,
                                        const Evaluation& temperature,
                                        const Evaluation& pressure) const
    { OPM_OIL_PVT_MULTIPLEXER_CALL(return pvtImpl.fugacityCoefficientWater(regionIdx, temperature, pressure)); return 0; }

    template <class Evaluation>
    Evaluation gasDissolutionFactor(unsigned regionIdx,
                                    const Evaluation& temperature,
                                    const Evaluation& pressure) const
    { OPM_OIL_PVT_MULTIPLEXER_CALL(return pvtImpl.gasDissolutionFactor(regionIdx, temperature, pressure)); return 0; }

    template <class Evaluation>
    Evaluation oilSaturationPressure(unsigned regionIdx,
                                     const Evaluation& temperature,
                                     const Evaluation& XoG) const
    { OPM_OIL_PVT_MULTIPLEXER_CALL(return pvtImpl.oilSaturationPressure(regionIdx, temperature, XoG)); return 0; }

    template <class Evaluation>
    Evaluation saturatedOilGasMassFraction(unsigned regionIdx,
                                           const Evaluation& temperature,
                                           const Evaluation& pressure) const
    { OPM_OIL_PVT_MULTIPLEXER_CALL(return pvtImpl.saturatedOilGasMassFraction(regionIdx, temperature, pressure)); return 0; }

    template <class Evaluation>
    Evaluation saturatedOilGasMoleFraction(unsigned regionIdx,
                                           const Evaluation& temperature,
                                           const Evaluation& pressure) const
    { OPM_OIL_PVT_MULTIPLEXER_CALL(return pvtImpl.saturatedOilGasMoleFraction(regionIdx, temperature, pressure)); return 0; }

    void setApproach(OilPvtApproach oilPvtApproach)
    {
        switch (oilPvtApproach) {
        case ConstantCompressibilityOilPvt:
            realOilPvt_ = new Opm::ConstantCompressibilityOilPvt<Scalar>;
            break;

        case DeadOilPvt:
            realOilPvt_ = new Opm::DeadOilPvt<Scalar>;
            break;

        case LiveOilPvt:
            realOilPvt_ = new Opm::LiveOilPvt<Scalar>;
            break;

        case NoOilPvt:
            OPM_THROW(std::logic_error, "Not implemented: Oil PVT of this deck!");
        }

        oilPvtApproach_ = oilPvtApproach;
    }

    OilPvtApproach oilPvtApproach() const
    { return oilPvtApproach_; }

    // get the parameter object for the dry oil case
    template <OilPvtApproach approachV>
    typename std::enable_if<approachV == LiveOilPvt, Opm::LiveOilPvt<Scalar> >::type& getRealOilPvt()
    {
        assert(oilPvtApproach() == approachV);
        return *static_cast<Opm::LiveOilPvt<Scalar>* >(realOilPvt_);
    }

    template <OilPvtApproach approachV>
    typename std::enable_if<approachV == LiveOilPvt, const Opm::LiveOilPvt<Scalar> >::type& getRealOilPvt() const
    {
        assert(oilPvtApproach() == approachV);
        return *static_cast<Opm::LiveOilPvt<Scalar>* >(realOilPvt_);
    }

    template <OilPvtApproach approachV>
    typename std::enable_if<approachV == DeadOilPvt, Opm::DeadOilPvt<Scalar> >::type& getRealOilPvt()
    {
        assert(oilPvtApproach() == approachV);
        return *static_cast<Opm::DeadOilPvt<Scalar>* >(realOilPvt_);
    }

    template <OilPvtApproach approachV>
    typename std::enable_if<approachV == DeadOilPvt, const Opm::DeadOilPvt<Scalar> >::type& getRealOilPvt() const
    {
        assert(oilPvtApproach() == approachV);
        return *static_cast<Opm::DeadOilPvt<Scalar>* >(realOilPvt_);
    }

    template <OilPvtApproach approachV>
    typename std::enable_if<approachV == ConstantCompressibilityOilPvt, Opm::ConstantCompressibilityOilPvt<Scalar> >::type& getRealOilPvt()
    {
        assert(oilPvtApproach() == approachV);
        return *static_cast<Opm::ConstantCompressibilityOilPvt<Scalar>* >(realOilPvt_);
    }

    template <OilPvtApproach approachV>
    typename std::enable_if<approachV == ConstantCompressibilityOilPvt, const Opm::ConstantCompressibilityOilPvt<Scalar> >::type& getRealOilPvt() const
    {
        assert(oilPvtApproach() == approachV);
        return *static_cast<Opm::ConstantCompressibilityOilPvt<Scalar>* >(realOilPvt_);
    }

private:
    OilPvtApproach oilPvtApproach_;
    void *realOilPvt_;
};

} // namespace Opm

#endif