InitStateEquil.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_INIT_STATE_EQUIL_HPP
#define OPM_INIT_STATE_EQUIL_HPP
 
#include <opm/models/utils/propertysystem.hh>
 
#include <opm/material/common/Tabulated1DFunction.hpp>
#include <opm/material/fluidstates/SimpleModularFluidState.hpp>
 
#include <opm/simulators/utils/ParallelCommunication.hpp>
 
#include <array>
#include <cstddef>
#include <memory>
#include <utility>
#include <vector>
#include <string>
 
namespace Opm {
 
class EclipseState;
class EquilRecord;
class NumericalAquifers;
 
namespace EQUIL {
 
class EquilReg;
namespace Miscibility { class RsFunction; }
 
namespace Details {
template <class RHS>
class RK4IVP {
public:
    RK4IVP(const RHS& f,
           const std::array<double,2>& span,
           const double y0,
           const int N);
 
    double
    operator()(const double x) const;
 
private:
    int N_;
    std::array<double,2> span_;
    std::vector<double>  y_;
    std::vector<double>  f_;
 
    double stepsize() const;
};
 
namespace PhasePressODE {
template <class FluidSystem>
class Water
{
using TabulatedFunction = Tabulated1DFunction<double>;
public:
    Water(const TabulatedFunction& tempVdTable,
          const TabulatedFunction& saltVdTable,
          const int pvtRegionIdx,
          const double normGrav);
 
    double operator()(const double depth,
                      const double press) const;
 
private:
    const TabulatedFunction& tempVdTable_;
    const TabulatedFunction& saltVdTable_;
    const int pvtRegionIdx_;
    const double g_;
 
    double density(const double depth,
                   const double press) const;
};
 
template <class FluidSystem, class RS>
class Oil
{
using TabulatedFunction = Tabulated1DFunction<double>;
public:
    Oil(const TabulatedFunction& tempVdTable,
        const RS& rs,
        const int pvtRegionIdx,
        const double normGrav);
 
    double operator()(const double depth,
                      const double press) const;
 
private:
    const TabulatedFunction& tempVdTable_;
    const RS& rs_;
    const int pvtRegionIdx_;
    const double g_;
 
    double density(const double depth,
                   const double press) const;
};
 
template <class FluidSystem, class RV, class RVW>
class Gas
{
using TabulatedFunction = Tabulated1DFunction<double>;
public:
    Gas(const TabulatedFunction& tempVdTable,
        const RV& rv,
        const RVW& rvw,
        const int pvtRegionIdx,
        const double normGrav);
 
    double operator()(const double depth,
                      const double press) const;
 
private:
    const TabulatedFunction& tempVdTable_;
    const RV& rv_;
    const RVW& rvw_;
    const int pvtRegionIdx_;
    const double g_;
 
    double density(const double depth,
                   const double press) const;
};
 
} // namespace PhasePressODE
 
template <class FluidSystem, class Region>
class PressureTable
{
public:
    using VSpan = std::array<double, 2>;
 
    explicit PressureTable(const double gravity,
                           const int    samplePoints = 2000);
 
    PressureTable(const PressureTable& rhs);
 
    PressureTable(PressureTable&& rhs);
 
    PressureTable& operator=(const PressureTable& rhs);
 
    PressureTable& operator=(PressureTable&& rhs);
 
    void equilibrate(const Region& reg,
                     const VSpan&  span);
 
    bool oilActive() const;
 
    bool gasActive() const;
 
    bool waterActive() const;
 
    double oil(const double depth) const;
 
    double gas(const double depth) const;
 
    double water(const double depth) const;
 
private:
    template <class ODE>
    class PressureFunction
    {
    public:
        struct InitCond {
            double depth;
            double pressure;
        };
 
        explicit PressureFunction(const ODE&      ode,
                                  const InitCond& ic,
                                  const int       nsample,
                                  const VSpan&    span);
 
        PressureFunction(const PressureFunction& rhs);
 
        PressureFunction(PressureFunction&& rhs) = default;
 
        PressureFunction& operator=(const PressureFunction& rhs);
 
        PressureFunction& operator=(PressureFunction&& rhs);
 
        double value(const double depth) const;
 
    private:
        enum Direction : std::size_t { Up, Down, NumDir };
 
        using Distribution = Details::RK4IVP<ODE>;
        using DistrPtr = std::unique_ptr<Distribution>;
 
        InitCond initial_;
        std::array<DistrPtr, Direction::NumDir> value_;
    };
 
    using OilPressODE = PhasePressODE::Oil<
        FluidSystem, typename Region::CalcDissolution
    >;
 
    using GasPressODE = PhasePressODE::Gas<
        FluidSystem, typename Region::CalcEvaporation, typename Region::CalcWaterEvaporation
    >;
 
    using WatPressODE = PhasePressODE::Water<FluidSystem>;
 
    using OPress = PressureFunction<OilPressODE>;
    using GPress = PressureFunction<GasPressODE>;
    using WPress = PressureFunction<WatPressODE>;
 
    using Strategy = void (PressureTable::*)
        (const Region&, const VSpan&);
 
    double gravity_;
    int    nsample_;
 
    std::unique_ptr<OPress> oil_{};
    std::unique_ptr<GPress> gas_{};
    std::unique_ptr<WPress> wat_{};
 
    template <typename PressFunc>
    void checkPtr(const PressFunc*   phasePress,
                  const std::string& phaseName) const;
 
    Strategy selectEquilibrationStrategy(const Region& reg) const;
 
    void copyInPointers(const PressureTable& rhs);
 
    void equil_WOG(const Region& reg, const VSpan& span);
    void equil_GOW(const Region& reg, const VSpan& span);
    void equil_OWG(const Region& reg, const VSpan& span);
 
    void makeOilPressure(const typename OPress::InitCond& ic,
                         const Region&                    reg,
                         const VSpan&                     span);
 
    void makeGasPressure(const typename GPress::InitCond& ic,
                         const Region&                    reg,
                         const VSpan&                     span);
 
    void makeWatPressure(const typename WPress::InitCond& ic,
                         const Region&                    reg,
                         const VSpan&                     span);
};
 
// ===========================================================================
 
struct PhaseQuantityValue {
    double oil{0.0};
    double gas{0.0};
    double water{0.0};
 
    PhaseQuantityValue& axpy(const PhaseQuantityValue& rhs, const double a)
    {
        this->oil   += a * rhs.oil;
        this->gas   += a * rhs.gas;
        this->water += a * rhs.water;
 
        return *this;
    }
 
    PhaseQuantityValue& operator/=(const double x)
    {
        this->oil   /= x;
        this->gas   /= x;
        this->water /= x;
 
        return *this;
    }
 
    void reset()
    {
        this->oil = this->gas = this->water = 0.0;
    }
};
 
template <class MaterialLawManager, class FluidSystem, class Region, typename CellID>
class PhaseSaturations
{
public:
    struct Position {
        CellID cell;
        double depth;
    };
 
    using PTable = PressureTable<FluidSystem, Region>;
 
    explicit PhaseSaturations(MaterialLawManager&        matLawMgr,
                              const std::vector<double>& swatInit);
 
    PhaseSaturations(const PhaseSaturations& rhs);
 
    PhaseSaturations& operator=(const PhaseSaturations&) = delete;
 
    PhaseSaturations& operator=(PhaseSaturations&&) = delete;
 
    const PhaseQuantityValue&
    deriveSaturations(const Position& x,
                      const Region&   reg,
                      const PTable&   ptable);
 
    const PhaseQuantityValue& correctedPhasePressures() const
    {
        return this->press_;
    }
 
private:
    struct EvaluationPoint {
        const Position* position{nullptr};
        const Region*   region  {nullptr};
        const PTable*   ptable  {nullptr};
    };
 
    using FluidState = ::Opm::
        SimpleModularFluidState<double, /*numPhases=*/3, /*numComponents=*/3,
                                FluidSystem,
                                /*storePressure=*/false,
                                /*storeTemperature=*/false,
                                /*storeComposition=*/false,
                                /*storeFugacity=*/false,
                                /*storeSaturation=*/true,
                                /*storeDensity=*/false,
                                /*storeViscosity=*/false,
                                /*storeEnthalpy=*/false>;
 
    using MaterialLaw = typename MaterialLawManager::MaterialLaw;
 
    using PhaseIdx = std::remove_cv_t<
        std::remove_reference_t<decltype(FluidSystem::oilPhaseIdx)>
    >;
 
    MaterialLawManager& matLawMgr_;
 
    const std::vector<double>& swatInit_;
 
    PhaseQuantityValue sat_;
 
    PhaseQuantityValue press_;
 
    EvaluationPoint evalPt_;
 
    FluidState fluidState_;
 
    std::array<double, FluidSystem::numPhases> matLawCapPress_;
 
    void setEvaluationPoint(const Position& x,
                            const Region&   reg,
                            const PTable&   ptable);
 
    void initializePhaseQuantities();
 
    void deriveOilSat();
 
    void deriveGasSat();
 
    void deriveWaterSat();
 
    void fixUnphysicalTransition();
 
    void accountForScaledSaturations();
 
    // --------------------------------------------------------------------
    // Note: Function 'applySwatInit' is non-const because the overload set
    // needs to mutate the 'matLawMgr_'.
    // --------------------------------------------------------------------
 
    std::pair<double, bool> applySwatInit(const double pcow);
 
    std::pair<double, bool> applySwatInit(const double pc, const double sw);
 
    void computeMaterialLawCapPress();
 
    double materialLawCapPressGasOil() const;
 
    double materialLawCapPressOilWater() const;
 
    double materialLawCapPressGasWater() const;
 
    bool isConstCapPress(const PhaseIdx phaseIdx) const;
 
    bool isOverlappingTransition() const;
 
    double fromDepthTable(const double   contactdepth,
                          const PhaseIdx phasePos,
                          const bool     isincr) const;
 
    double invertCapPress(const double   pc,
                          const PhaseIdx phasePos,
                          const bool     isincr) const;
 
    PhaseIdx oilPos() const
    {
        return FluidSystem::oilPhaseIdx;
    }
 
    PhaseIdx gasPos() const
    {
        return FluidSystem::gasPhaseIdx;
    }
 
    PhaseIdx waterPos() const
    {
        return FluidSystem::waterPhaseIdx;
    }
};
 
// ===========================================================================
 
template <typename CellRange>
void verticalExtent(const CellRange&      cells,
                    const std::vector<std::pair<double, double>>& cellZMinMax,
                    const Parallel::Communication& comm,
                    std::array<double,2>& span);
 
template <class Element>
std::pair<double,double> cellZMinMax(const Element& element);
 
} // namespace Details
 
namespace DeckDependent {
 
template<class FluidSystem,
         class Grid,
         class GridView,
         class ElementMapper,
         class CartesianIndexMapper>
class InitialStateComputer
{
    using Element = typename GridView::template Codim<0>::Entity;
public:
    template<class MaterialLawManager>
    InitialStateComputer(MaterialLawManager& materialLawManager,
                         const EclipseState& eclipseState,
                         const Grid& grid,
                         const GridView& gridView,
                         const CartesianIndexMapper& cartMapper,
                         const double grav,
                         const int num_pressure_points = 2000,
                         const bool applySwatInit = true);
 
    using Vec = std::vector<double>;
    using PVec = std::vector<Vec>; // One per phase.
 
    const Vec& temperature() const { return temperature_; }
    const Vec& saltConcentration() const { return saltConcentration_; }
    const Vec& saltSaturation() const { return saltSaturation_; }
    const PVec& press() const { return pp_; }
    const PVec& saturation() const { return sat_; }
    const Vec& rs() const { return rs_; }
    const Vec& rv() const { return rv_; }
    const Vec& rvw() const { return rvw_; }
 
private:
    template <class RMap>
    void updateInitialTemperature_(const EclipseState& eclState, const RMap& reg);
 
    template <class RMap>
    void updateInitialSaltConcentration_(const EclipseState& eclState, const RMap& reg);
 
    template <class RMap>
    void updateInitialSaltSaturation_(const EclipseState& eclState, const RMap& reg);
 
    void updateCellProps_(const GridView& gridView, 
                          const NumericalAquifers& aquifer);
 
    void applyNumericalAquifers_(const GridView& gridView,
                                 const NumericalAquifers& aquifer,
                                 const bool co2store_or_h2store);
 
    template<class RMap>
    void setRegionPvtIdx(const EclipseState& eclState, const RMap& reg);
 
    template <class RMap, class MaterialLawManager, class Comm>
    void calcPressSatRsRv(const RMap& reg,
                          const std::vector<EquilRecord>& rec,
                          MaterialLawManager& materialLawManager,
                          const Comm& comm,
                          const double grav);
 
    template <class CellRange, class EquilibrationMethod>
    void cellLoop(const CellRange&      cells,
                  EquilibrationMethod&& eqmethod);
 
    template <class CellRange, class PressTable, class PhaseSat>
    void equilibrateCellCentres(const CellRange&         cells,
                                const EquilReg&          eqreg,
                                const PressTable&        ptable,
                                PhaseSat&                psat);
 
    template <class CellRange, class PressTable, class PhaseSat>
    void equilibrateHorizontal(const CellRange&  cells,
                               const EquilReg&   eqreg,
                               const int         acc,
                               const PressTable& ptable,
                               PhaseSat&         psat);
 
    std::vector< std::shared_ptr<Miscibility::RsFunction> > rsFunc_;
    std::vector< std::shared_ptr<Miscibility::RsFunction> > rvFunc_;
    std::vector< std::shared_ptr<Miscibility::RsFunction> > rvwFunc_;
    using TabulatedFunction = Tabulated1DFunction<double>;
    std::vector<TabulatedFunction> tempVdTable_;
    std::vector<TabulatedFunction> saltVdTable_;
    std::vector<TabulatedFunction> saltpVdTable_;
    std::vector<int> regionPvtIdx_;
    Vec temperature_;
    Vec saltConcentration_;
    Vec saltSaturation_;
    PVec pp_;
    PVec sat_;
    Vec rs_;
    Vec rv_;
    Vec rvw_;
    const CartesianIndexMapper& cartesianIndexMapper_;
    Vec swatInit_;
    Vec cellCenterDepth_;
    std::vector<std::pair<double,double>> cellZSpan_;
    std::vector<std::pair<double,double>> cellZMinMax_;
    int num_pressure_points_;
};
 
} // namespace DeckDependent
} // namespace EQUIL
} // namespace Opm
 
#endif // OPM_INIT_STATE_EQUIL_HPP