GasPvtMultiplexer.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_GAS_PVT_MULTIPLEXER_HPP
#define OPM_GAS_PVT_MULTIPLEXER_HPP

#include "DryGasPvt.hpp"
#include "WetGasPvt.hpp"

#if HAVE_OPM_PARSER
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
#endif

namespace Opm {
template <class Scalar>
class OilPvtMultiplexer;

#define OPM_GAS_PVT_MULTIPLEXER_CALL(codeToCall)                        \
    switch (gasPvtApproach_) {                                          \
    case DryGasPvt: {                                                   \
        auto &pvtImpl = getRealGasPvt<DryGasPvt>();                     \
        codeToCall;                                                     \
        break;                                                          \
    }                                                                   \
    case WetGasPvt: {                                                   \
        auto &pvtImpl = getRealGasPvt<WetGasPvt>();                     \
        codeToCall;                                                     \
        break;                                                          \
    }                                                                   \
    case NoGasPvt:                                                      \
        OPM_THROW(std::logic_error, "Not implemented: Gas PVT of this deck!"); \
    }


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

public:
    enum GasPvtApproach {
        NoGasPvt,
        DryGasPvt,
        WetGasPvt
    };

    GasPvtMultiplexer()
    {
        gasPvtApproach_ = NoGasPvt;
    }

    ~GasPvtMultiplexer()
    {
        switch (gasPvtApproach_) {
        case DryGasPvt: {
            delete &getRealGasPvt<DryGasPvt>();
            break;
        }
        case WetGasPvt: {
            delete &getRealGasPvt<WetGasPvt>();
            break;
        }
        case NoGasPvt:
            break;
        }
    }

#if HAVE_OPM_PARSER

    void initFromDeck(DeckConstPtr deck, EclipseStateConstPtr eclState)
    {
        if (deck->hasKeyword("PVTG"))
            setApproach(WetGasPvt);
        else if (deck->hasKeyword("PVDG"))
            setApproach(DryGasPvt);

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

    void setApproach(GasPvtApproach gasPvtApproach)
    {
        switch (gasPvtApproach) {
        case DryGasPvt:
            realGasPvt_ = new Opm::DryGasPvt<Scalar>;
            break;

        case WetGasPvt:
            realGasPvt_ = new Opm::WetGasPvt<Scalar>;
            break;

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

        gasPvtApproach_ = gasPvtApproach;
    }

    void initEnd(const OilPvtMultiplexer *oilPvt)
    { OPM_GAS_PVT_MULTIPLEXER_CALL(pvtImpl.initEnd(oilPvt)); }

    template <class Evaluation = Scalar>
    Evaluation viscosity(unsigned regionIdx,
                         const Evaluation& temperature,
                         const Evaluation& pressure,
                         const Evaluation& XgO) const
    { OPM_GAS_PVT_MULTIPLEXER_CALL(return pvtImpl.viscosity(regionIdx, temperature, pressure, XgO)); return 0; }

    template <class Evaluation = Scalar>
    Evaluation formationVolumeFactor(unsigned regionIdx,
                                     const Evaluation& temperature,
                                     const Evaluation& pressure,
                                     const Evaluation& XgO) const
    { OPM_GAS_PVT_MULTIPLEXER_CALL(return pvtImpl.formationVolumeFactor(regionIdx, temperature, pressure, XgO)); return 0; }

    template <class Evaluation = Scalar>
    Evaluation density(unsigned regionIdx,
                       const Evaluation& temperature,
                       const Evaluation& pressure,
                       const Evaluation& XgO) const
    { OPM_GAS_PVT_MULTIPLEXER_CALL(return pvtImpl.density(regionIdx, temperature, pressure, XgO)); return 0; }

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

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

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

    template <class Evaluation = Scalar>
    Evaluation oilVaporizationFactor(unsigned regionIdx,
                                     const Evaluation& temperature,
                                     const Evaluation& pressure) const
    { OPM_GAS_PVT_MULTIPLEXER_CALL(return pvtImpl.oilVaporizationFactor(regionIdx, temperature, pressure)); return 0; }

    template <class Evaluation = Scalar>
    Evaluation gasSaturationPressure(unsigned regionIdx,
                                     const Evaluation& temperature,
                                     const Evaluation& XgO) const
    { OPM_GAS_PVT_MULTIPLEXER_CALL(return pvtImpl.gasSaturationPressure(regionIdx, temperature, XgO)); return 0; }

    template <class Evaluation = Scalar>
    Evaluation saturatedGasOilMassFraction(unsigned regionIdx,
                                           const Evaluation& temperature,
                                           const Evaluation& pressure) const
    { OPM_GAS_PVT_MULTIPLEXER_CALL(return pvtImpl.saturatedGasOilMassFraction(regionIdx, temperature, pressure)); return 0; }

    template <class Evaluation = Scalar>
    Evaluation saturatedGasOilMoleFraction(unsigned regionIdx,
                                           const Evaluation& temperature,
                                           const Evaluation& pressure) const
    { OPM_GAS_PVT_MULTIPLEXER_CALL(return pvtImpl.saturatedGasOilMoleFraction(regionIdx, temperature, pressure)); return 0; }


    GasPvtApproach gasPvtApproach() const
    { return gasPvtApproach_; }

    // get the parameter object for the dry gas case
    template <GasPvtApproach approachV>
    typename std::enable_if<approachV == DryGasPvt, Opm::DryGasPvt<Scalar> >::type& getRealGasPvt()
    {
        assert(gasPvtApproach() == approachV);
        return *static_cast<Opm::DryGasPvt<Scalar>* >(realGasPvt_);
    }

    template <GasPvtApproach approachV>
    typename std::enable_if<approachV == DryGasPvt, const Opm::DryGasPvt<Scalar> >::type& getRealGasPvt() const
    {
        assert(gasPvtApproach() == approachV);
        return *static_cast<const Opm::DryGasPvt<Scalar>* >(realGasPvt_);
    }

    // get the parameter object for the wet gas case
    template <GasPvtApproach approachV>
    typename std::enable_if<approachV == WetGasPvt, Opm::WetGasPvt<Scalar> >::type& getRealGasPvt()
    {
        assert(gasPvtApproach() == approachV);
        return *static_cast<Opm::WetGasPvt<Scalar>* >(realGasPvt_);
    }

    template <GasPvtApproach approachV>
    typename std::enable_if<approachV == WetGasPvt, const Opm::WetGasPvt<Scalar> >::type& getRealGasPvt() const
    {
        assert(gasPvtApproach() == approachV);
        return *static_cast<const Opm::WetGasPvt<Scalar>* >(realGasPvt_);
    }

private:
    GasPvtApproach gasPvtApproach_;
    void *realGasPvt_;
};

#undef OPM_GAS_MULTIPLEXER_CALL

} // namespace Opm

#endif