EquilibrationHelpers.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:
/*
  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 3 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/>.
 
  Consult the COPYING file in the top-level source directory of this
  module for the precise wording of the license and the list of
  copyright holders.
*/
#ifndef OPM_EQUILIBRATION_HELPERS_HPP
#define OPM_EQUILIBRATION_HELPERS_HPP
 
#include <opm/material/common/Tabulated1DFunction.hpp>
 
#include <opm/input/eclipse/EclipseState/InitConfig/Equil.hpp>
 
#include <memory>
#include <vector>
 
/*
  ---- synopsis of EquilibrationHelpers.hpp ----
 
  namespace Opm
  {
  namespace EQUIL {
 
  namespace Miscibility {
  class RsFunction;
  class NoMixing;
  template <class FluidSystem>
  class RsVD;
  template <class FluidSystem>
  class RsSatAtContact;
  }
 
  class EquilReg;
 
 
  template <class FluidSystem, class MaterialLawManager>
  struct PcEq;
 
  template <class FluidSystem, class MaterialLawManager>
  double satFromPc(const MaterialLawManager& materialLawManager,
  const int phase,
  const int cell,
  const double targetPc,
  const bool increasing = false)
  template <class FluidSystem, class MaterialLawManager>
  double satFromSumOfPcs(const MaterialLawManager& materialLawManager,
  const int phase1,
  const int phase2,
  const int cell,
  const double targetPc)
  } // namespace Equil
  } // namespace Opm
 
  ---- end of synopsis of EquilibrationHelpers.hpp ----
*/
 
namespace Opm {
 
namespace EQUIL {
 
namespace Miscibility {
 
class RsFunction
{
public:
    virtual ~RsFunction() = default;
 
    virtual double operator()(const double depth,
                              const double press,
                              const double temp,
                              const double sat = 0.0) const = 0;
};
 
 
class NoMixing : public RsFunction
{
public:
    virtual ~NoMixing() = default;
 
    double
    operator()(const double /* depth */,
               const double /* press */,
               const double /* temp */,
               const double /* sat */ = 0.0) const
    {
        return 0.0;
    }
};
 
 
template <class FluidSystem>
class RsVD : public RsFunction
{
public:
    RsVD(const int pvtRegionIdx,
         const std::vector<double>& depth,
         const std::vector<double>& rs);
 
    virtual ~RsVD() = default;
 
    double operator()(const double depth,
                      const double press,
                      const double temp,
                      const double satGas = 0.0) const;
 
private:
    using RsVsDepthFunc = Tabulated1DFunction<double>;
 
    const int pvtRegionIdx_;
    RsVsDepthFunc rsVsDepth_;
 
    double satRs(const double press, const double temp) const;
};
 
 
template <class FluidSystem>
class PBVD : public RsFunction
{
public:
    PBVD(const int pvtRegionIdx,
         const std::vector<double>& depth,
         const std::vector<double>& pbub);
 
    virtual ~PBVD() = default;
 
    double operator()(const double depth,
                      const double cellPress,
                      const double temp,
                      const double satGas = 0.0) const;
 
private:
    using PbubVsDepthFunc = Tabulated1DFunction<double>;
 
    const int pvtRegionIdx_;
    PbubVsDepthFunc pbubVsDepth_;
 
    double satRs(const double press, const double temp) const;
};
 
 
template <class FluidSystem>
class PDVD : public RsFunction
{
public:
    PDVD(const int pvtRegionIdx,
         const std::vector<double>& depth,
         const std::vector<double>& pdew);
 
    virtual ~PDVD() = default;
 
    double operator()(const double depth,
                      const double cellPress,
                      const double temp,
                      const double satOil = 0.0) const;
 
private:
    using PdewVsDepthFunc = Tabulated1DFunction<double>;
 
    const int pvtRegionIdx_;
    PdewVsDepthFunc pdewVsDepth_;
 
    double satRv(const double press, const double temp) const;
};
 
 
template <class FluidSystem>
class RvVD : public RsFunction
{
public:
    RvVD(const int pvtRegionIdx,
         const std::vector<double>& depth,
         const std::vector<double>& rv);
 
    double operator()(const double depth,
                      const double press,
                      const double temp,
                      const double satOil = 0.0) const;
 
private:
    using RvVsDepthFunc = Tabulated1DFunction<double>;
 
    const int pvtRegionIdx_;
    RvVsDepthFunc rvVsDepth_;
 
    double satRv(const double press, const double temp) const;
};
 
 
template <class FluidSystem>
class RvwVD : public RsFunction
{
public:
    RvwVD(const int pvtRegionIdx,
         const std::vector<double>& depth,
         const std::vector<double>& rvw);
 
    double operator()(const double depth,
                      const double press,
                      const double temp,
                      const double satWat = 0.0) const;
 
private:
    using RvwVsDepthFunc = Tabulated1DFunction<double>;
 
    const int pvtRegionIdx_;
    RvwVsDepthFunc rvwVsDepth_;
 
    double satRvw(const double press, const double temp) const;
};
 
 
template <class FluidSystem>
class RsSatAtContact : public RsFunction
{
public:
    RsSatAtContact(const int pvtRegionIdx, const double pContact,  const double T_contact);
 
    double operator()(const double /* depth */,
                      const double press,
                      const double temp,
                      const double satGas = 0.0) const;
 
private:
    const int pvtRegionIdx_;
    double rsSatContact_;
 
    double satRs(const double press, const double temp) const;
};
 
 
template <class FluidSystem>
class RvSatAtContact : public RsFunction
{
public:
    RvSatAtContact(const int pvtRegionIdx, const double pContact, const double T_contact);
 
    double operator()(const double /*depth*/,
                      const double press,
                      const double temp,
                      const double satOil = 0.0) const;
 
private:
    const int pvtRegionIdx_;
    double rvSatContact_;
 
    double satRv(const double press, const double temp) const;
};
 
template <class FluidSystem>
class RvwSatAtContact : public RsFunction
{
public:
    RvwSatAtContact(const int pvtRegionIdx, const double pContact, const double T_contact);
 
    double operator()(const double /*depth*/,
                      const double press,
                      const double temp,
                      const double satWat = 0.0) const;
 
private:
    const int pvtRegionIdx_;
    double rvwSatContact_;
 
    double satRvw(const double press, const double temp) const;
};
 
} // namespace Miscibility
 
class EquilReg
{
    using TabulatedFunction = Tabulated1DFunction<double>;
 
public:
    EquilReg(const EquilRecord& rec,
             std::shared_ptr<Miscibility::RsFunction> rs,
             std::shared_ptr<Miscibility::RsFunction> rv,
             std::shared_ptr<Miscibility::RsFunction> rvw,
             const TabulatedFunction& tempVdTable,
             const TabulatedFunction& saltVdTable,
             const int pvtIdx);
 
    using CalcDissolution = Miscibility::RsFunction;
 
    using CalcEvaporation = Miscibility::RsFunction;
 
    using CalcWaterEvaporation = Miscibility::RsFunction;
 
 
    double datum() const;
 
    double pressure() const;
 
    double zwoc() const;
 
    double pcowWoc() const;
 
    double zgoc() const;
 
    double pcgoGoc() const;
 
    int equilibrationAccuracy() const;
 
    const CalcDissolution& dissolutionCalculator() const;
 
    const CalcEvaporation& evaporationCalculator() const;
 
    const CalcWaterEvaporation& waterEvaporationCalculator() const;
 
    const TabulatedFunction& saltVdTable() const;
    const TabulatedFunction& tempVdTable() const;
 
    int pvtIdx() const;
 
private:
    EquilRecord rec_;     
    std::shared_ptr<Miscibility::RsFunction> rs_;      
    std::shared_ptr<Miscibility::RsFunction> rv_;      
    std::shared_ptr<Miscibility::RsFunction> rvw_;      
    const TabulatedFunction& tempVdTable_;
    const TabulatedFunction& saltVdTable_;
    const int pvtIdx_;
};
 
 
 
template <class FluidSystem, class MaterialLawManager>
struct PcEq
{
    PcEq(const MaterialLawManager& materialLawManager,
         const int phase,
         const int cell,
         const double targetPc);
 
    double operator()(double s) const;
 
private:
    const MaterialLawManager& materialLawManager_;
    const int phase_;
    const int cell_;
    const double targetPc_;
};
 
template <class FluidSystem, class MaterialLawManager>
double minSaturations(const MaterialLawManager& materialLawManager,
                      const int phase, const int cell);
 
template <class FluidSystem, class MaterialLawManager>
double maxSaturations(const MaterialLawManager& materialLawManager,
                      const int phase, const int cell);
 
template <class FluidSystem, class MaterialLawManager>
double satFromPc(const MaterialLawManager& materialLawManager,
                 const int phase,
                 const int cell,
                 const double targetPc,
                 const bool increasing = false);
 
template <class FluidSystem, class MaterialLawManager>
struct PcEqSum
{
    PcEqSum(const MaterialLawManager& materialLawManager,
            const int phase1,
            const int phase2,
            const int cell,
            const double targetPc);
 
    double operator()(double s) const;
 
private:
    const MaterialLawManager& materialLawManager_;
    const int phase1_;
    const int phase2_;
    const int cell_;
    const double targetPc_;
};
 
template <class FluidSystem, class MaterialLawManager>
double satFromSumOfPcs(const MaterialLawManager& materialLawManager,
                       const int phase1,
                       const int phase2,
                       const int cell,
                       const double targetPc);
 
template <class FluidSystem, class MaterialLawManager>
double satFromDepth(const MaterialLawManager& materialLawManager,
                    const double cellDepth,
                    const double contactDepth,
                    const int phase,
                    const int cell,
                    const bool increasing = false);
 
template <class FluidSystem, class MaterialLawManager>
bool isConstPc(const MaterialLawManager& materialLawManager,
               const int phase,
               const int cell);
 
} // namespace Equil
} // namespace Opm
 
#endif // OPM_EQUILIBRATION_HELPERS_HPP