ConstantCompressibilityOilPvt.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_CONSTANT_COMPRESSIBILITY_OIL_PVT_HPP
#define OPM_CONSTANT_COMPRESSIBILITY_OIL_PVT_HPP

#include <opm/material/common/OpmFinal.hpp>
#include <opm/material/common/UniformXTabulated2DFunction.hpp>
#include <opm/material/common/Tabulated1DFunction.hpp>
#include <opm/material/common/Spline.hpp>

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

namespace Opm {
template <class Scalar>
class GasPvtMultiplexer;

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

    typedef Opm::Tabulated1DFunction<Scalar> TabulatedOneDFunction;
    typedef std::vector<std::pair<Scalar, Scalar> > SamplingPoints;

public:
#if HAVE_OPM_PARSER

    void initFromDeck(DeckConstPtr deck, EclipseStateConstPtr /*eclState*/)
    {
        DeckKeywordConstPtr pvcdoKeyword = deck->getKeyword("PVCDO");
        DeckKeywordConstPtr densityKeyword = deck->getKeyword("DENSITY");

        assert(pvcdoKeyword->size() == densityKeyword->size());

        size_t numRegions = pvcdoKeyword->size();
        setNumRegions(numRegions);

        for (unsigned regionIdx = 0; regionIdx < numRegions; ++ regionIdx) {
            Scalar rhoRefO = densityKeyword->getRecord(regionIdx)->getItem("OIL")->getSIDouble(0);
            Scalar rhoRefG = densityKeyword->getRecord(regionIdx)->getItem("GAS")->getSIDouble(0);
            Scalar rhoRefW = densityKeyword->getRecord(regionIdx)->getItem("WATER")->getSIDouble(0);

            setReferenceDensities(regionIdx, rhoRefO, rhoRefG, rhoRefW);

            auto pvcdoRecord = pvcdoKeyword->getRecord(regionIdx);
            oilReferencePressure_[regionIdx] =
                pvcdoRecord->getItem("P_REF")->getSIDouble(0);
            oilReferenceFormationVolumeFactor_[regionIdx] =
                pvcdoRecord->getItem("OIL_VOL_FACTOR")->getSIDouble(0);
            oilCompressibility_[regionIdx] =
                pvcdoRecord->getItem("OIL_COMPRESSIBILITY")->getSIDouble(0);
            oilViscosity_[regionIdx] =
                pvcdoRecord->getItem("OIL_VISCOSITY")->getSIDouble(0);
            oilViscosibility_[regionIdx] =
                pvcdoRecord->getItem("OIL_VISCOSIBILITY")->getSIDouble(0);
        }
    }
#endif

    void setNumRegions(size_t numRegions)
    {
        oilReferenceDensity_.resize(numRegions);
        oilReferencePressure_.resize(numRegions);
        oilReferenceFormationVolumeFactor_.resize(numRegions);
        oilCompressibility_.resize(numRegions);
        oilViscosity_.resize(numRegions);
        oilViscosibility_.resize(numRegions);

        for (unsigned regionIdx = 0; regionIdx < numRegions; ++regionIdx) {
            setReferenceFormationVolumeFactor(regionIdx, 1.0);
            setReferencePressure(regionIdx, 1.03125);
        }
    }

    void setReferenceDensities(unsigned regionIdx,
                               Scalar rhoRefOil,
                               Scalar /*rhoRefGas*/,
                               Scalar /*rhoRefWater*/)
    {
        oilReferenceDensity_[regionIdx] = rhoRefOil;
    }

    void setMolarMasses(unsigned /*regionIdx*/,
                        Scalar /*MOil*/,
                        Scalar /*MGas*/,
                        Scalar /*MWater*/)
    { }

    void setViscosity(unsigned regionIdx, Scalar muo, Scalar oilViscosibility = 0.0)
    {
        oilViscosity_[regionIdx] = muo;
        oilViscosibility_[regionIdx] = oilViscosibility;
    }

    void setCompressibility(unsigned regionIdx, Scalar oilCompressibility)
    { oilCompressibility_[regionIdx] = oilCompressibility; }

    void setReferencePressure(unsigned regionIdx, Scalar p)
    { oilReferencePressure_[regionIdx] = p; }

    void setReferenceFormationVolumeFactor(unsigned regionIdx, Scalar BoRef)
    { oilReferenceFormationVolumeFactor_[regionIdx] = BoRef; }

    void setViscosibility(unsigned regionIdx, Scalar muComp)
    { oilViscosibility_[regionIdx] = muComp; }

    void initEnd(const GasPvtMultiplexer */*gasPvt*/)
    { }

    template <class Evaluation>
        Evaluation viscosity(unsigned regionIdx,
                             const Evaluation& temperature,
                             const Evaluation& pressure,
                             const Evaluation& XoG) const
    {
        // Eclipse calculates the viscosity in a weird way: it
        // calcultes the product of B_w and mu_w and then divides the
        // result by B_w...
        Scalar BoMuoRef = oilViscosity_[regionIdx]*oilReferenceFormationVolumeFactor_[regionIdx];
        const Evaluation& Bo = formationVolumeFactor(regionIdx, temperature, pressure, XoG);

        Scalar pRef = oilReferencePressure_[regionIdx];
        const Evaluation& Y =
            (oilCompressibility_[regionIdx] - oilViscosibility_[regionIdx])
            * (pressure - pRef);
        return BoMuoRef/((1 + Y*(1 + Y/2))*Bo);
    }

    template <class Evaluation>
        Evaluation density(unsigned regionIdx,
                           const Evaluation& temperature,
                           const Evaluation& pressure,
                           const Evaluation& XoG) const
    {
        const Evaluation& Bo = formationVolumeFactor(regionIdx, temperature, pressure, XoG);
        Scalar rhooRef = oilReferenceDensity_[regionIdx];
        return rhooRef/Bo;
    }

    template <class Evaluation>
        Evaluation formationVolumeFactor(unsigned regionIdx,
                                         const Evaluation& /*temperature*/,
                                         const Evaluation& pressure,
                                         const Evaluation& /*XoG*/) const
    {
        // cf. ECLiPSE 2011 technical description, p. 116
        Scalar pRef = oilReferencePressure_[regionIdx];
        const Evaluation& X = oilCompressibility_[regionIdx]*(pressure - pRef);

        Scalar BoRef = oilReferenceFormationVolumeFactor_[regionIdx];
        return BoRef/(1 + X*(1 + X/2));
    }

    template <class Evaluation>
        Evaluation fugacityCoefficientOil(unsigned /*regionIdx*/,
                                          const Evaluation& /*temperature*/,
                                          const Evaluation& pressure) const
    {
        // set the oil component fugacity coefficient in oil phase
        // arbitrarily. we use some pseudo-realistic value for the vapor
        // pressure to ease physical interpretation of the results
        return 20e3/pressure;
    }

    template <class Evaluation>
        Evaluation fugacityCoefficientWater(unsigned regionIdx,
                                            const Evaluation& temperature,
                                            const Evaluation& pressure) const
    {
        // assume that the affinity of the water component to the oil phase is many orders
        // of magnitude smaller than that of the oil component
        return 1e8*fugacityCoefficientOil(regionIdx, temperature, pressure);
    }

    template <class Evaluation>
        Evaluation fugacityCoefficientGas(unsigned regionIdx,
                                          const Evaluation& temperature,
                                          const Evaluation& pressure) const
    {
        // assume that the affinity of the gas component to the oil phase is many orders
        // of magnitude smaller than that of the oil component
        return 1.01e8*fugacityCoefficientOil(regionIdx, temperature, pressure);
    }

    template <class Evaluation>
        Evaluation gasDissolutionFactor(unsigned /*regionIdx*/,
                                        const Evaluation& /*temperature*/,
                                        const Evaluation& /*pressure*/) const
    { return 0.0; /* this is dead oil! */ }

    template <class Evaluation>
        Evaluation oilSaturationPressure(unsigned /*regionIdx*/,
                                         const Evaluation& /*temperature*/,
                                         const Evaluation& /*XoG*/) const
    { return 0.0; /* this is dead oil, so there isn't any meaningful saturation pressure! */ }

    template <class Evaluation>
        Evaluation saturatedOilGasMassFraction(unsigned /*regionIdx*/,
                                               const Evaluation& /*temperature*/,
                                               const Evaluation& /*pressure*/) const
    { return 0.0; /* this is dead oil! */ }

    template <class Evaluation>
        Evaluation saturatedOilGasMoleFraction(unsigned /*regionIdx*/,
                                               const Evaluation& /*temperature*/,
                                               const Evaluation& /*pressure*/) const
    { return 0.0; /* this is dead oil! */ }

private:
    std::vector<Scalar> oilReferenceDensity_;
    std::vector<Scalar> oilReferencePressure_;
    std::vector<Scalar> oilReferenceFormationVolumeFactor_;
    std::vector<Scalar> oilCompressibility_;
    std::vector<Scalar> oilViscosity_;
    std::vector<Scalar> oilViscosibility_;
};

} // namespace Opm

#endif