ECLEndPointScaling.hpp

Go to the documentation of this file.

/*
  Copyright 2017 Statoil ASA.
 
  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/>.
*/
 
#ifndef OPM_ECLENDPOINTSCALING_HEADER_INCLUDED
#define OPM_ECLENDPOINTSCALING_HEADER_INCLUDED
 
#include <opm/utility/ECLPhaseIndex.hpp>
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
 
namespace Opm {
 
    class ECLGraph;
    class ECLInitFileData;
 
} // namespace Opm
 
namespace Opm { namespace SatFunc {
 
    class EPSEvalInterface
    {
    public:
        struct TableEndPoints {
            double low;
 
            double disp;
 
            double high;
        };
 
        struct SaturationAssoc {
            std::vector<int>::size_type cell;
 
            double sat;
        };
 
        using SaturationPoints = std::vector<SaturationAssoc>;
 
        virtual std::vector<double>
        eval(const TableEndPoints&   tep,
             const SaturationPoints& sp) const = 0;
 
        virtual std::vector<double>
        reverse(const TableEndPoints&   tep,
                const SaturationPoints& sp) const = 0;
 
        virtual std::unique_ptr<EPSEvalInterface> clone() const = 0;
 
        virtual ~EPSEvalInterface();
    };
 
    class VerticalScalingInterface
    {
    public:
        struct FunctionValues {
            struct Point {
                double sat;
                double val;
            };
 
            Point disp;
            Point max;
        };
 
        using SaturationAssoc = EPSEvalInterface::SaturationAssoc;
 
        using SaturationPoints = EPSEvalInterface::SaturationPoints;
 
        virtual std::vector<double>
        vertScale(const FunctionValues&      f,
                  const SaturationPoints&    sp,
                  const std::vector<double>& val) const = 0;
 
        virtual std::unique_ptr<VerticalScalingInterface> clone() const = 0;
 
        virtual ~VerticalScalingInterface();
    };
 
    class TwoPointScaling : public EPSEvalInterface
    {
    public:
        TwoPointScaling(std::vector<double> smin,
                        std::vector<double> smax);
 
        ~TwoPointScaling();
 
        TwoPointScaling(const TwoPointScaling& rhs);
 
        TwoPointScaling(TwoPointScaling&& rhs);
 
        TwoPointScaling&
        operator=(const TwoPointScaling& rhs);
 
        TwoPointScaling&
        operator=(TwoPointScaling&& rhs);
 
        virtual std::vector<double>
        eval(const TableEndPoints&   tep,
             const SaturationPoints& sp) const override;
 
        virtual std::vector<double>
        reverse(const TableEndPoints&   tep,
                const SaturationPoints& sp) const override;
 
        virtual std::unique_ptr<EPSEvalInterface> clone() const override;
 
    private:
        class Impl;
 
        std::unique_ptr<Impl> pImpl_;
    };
 
    class PureVerticalScaling : public VerticalScalingInterface
    {
    public:
        explicit PureVerticalScaling(std::vector<double> fmax);
 
        virtual ~PureVerticalScaling();
 
        PureVerticalScaling(const PureVerticalScaling& rhs);
 
        PureVerticalScaling(PureVerticalScaling&& rhs);
 
        PureVerticalScaling& operator=(const PureVerticalScaling& rhs);
 
        PureVerticalScaling& operator=(PureVerticalScaling&& rhs);
 
        virtual std::vector<double>
        vertScale(const FunctionValues&      f,
                  const SaturationPoints&    sp,
                  const std::vector<double>& val) const override;
 
        virtual std::unique_ptr<VerticalScalingInterface>
        clone() const override;
 
    private:
        class Impl;
 
        std::unique_ptr<Impl> pImpl_;
    };
 
    class ThreePointScaling : public EPSEvalInterface
    {
    public:
        ThreePointScaling(std::vector<double> smin,
                          std::vector<double> sdisp,
                          std::vector<double> smax);
 
        ~ThreePointScaling();
 
        ThreePointScaling(const ThreePointScaling& rhs);
 
        ThreePointScaling(ThreePointScaling&& rhs);
 
        ThreePointScaling&
        operator=(const ThreePointScaling& rhs);
 
        ThreePointScaling&
        operator=(ThreePointScaling&& rhs);
 
        virtual std::vector<double>
        eval(const TableEndPoints&   tep,
             const SaturationPoints& sp) const override;
 
        virtual std::vector<double>
        reverse(const TableEndPoints&   tep,
                const SaturationPoints& sp) const override;
 
        virtual std::unique_ptr<EPSEvalInterface> clone() const override;
 
    private:
        class Impl;
 
        std::unique_ptr<Impl> pImpl_;
    };
 
    class CritSatVerticalScaling : public VerticalScalingInterface
    {
    public:
        explicit CritSatVerticalScaling(std::vector<double> sdisp,
                                        std::vector<double> fdisp,
                                        std::vector<double> smax,
                                        std::vector<double> fmax);
 
        virtual ~CritSatVerticalScaling();
 
        CritSatVerticalScaling(const CritSatVerticalScaling& rhs);
 
        CritSatVerticalScaling(CritSatVerticalScaling&& rhs);
 
        CritSatVerticalScaling& operator=(const CritSatVerticalScaling& rhs);
 
        CritSatVerticalScaling& operator=(CritSatVerticalScaling&& rhs);
 
        virtual std::vector<double>
        vertScale(const FunctionValues&      f,
                  const SaturationPoints&    sp,
                  const std::vector<double>& val) const override;
 
        virtual std::unique_ptr<VerticalScalingInterface>
        clone() const override;
 
    private:
        class Impl;
 
        std::unique_ptr<Impl> pImpl_;
    };
 
    struct CreateEPS
    {
        enum class FunctionCategory {
            Relperm,
 
            CapPress,
        };
 
        enum class SubSystem {
            OilWater,
 
            OilGas,
        };
 
        struct EPSOptions {
            bool use3PtScaling;
 
            FunctionCategory curve;
 
            SubSystem subSys;
 
            ::Opm::ECLPhaseIndex thisPh;
        };
 
        struct RawTableEndPoints {
            struct Connate {
                std::vector<double> oil;
 
                std::vector<double> gas;
 
                std::vector<double> water;
            };
 
            struct Critical {
                std::vector<double> oil_in_gas;
 
                std::vector<double> oil_in_water;
 
                std::vector<double> gas;
 
                std::vector<double> water;
            };
 
            struct Maximum {
                std::vector<double> oil;
 
                std::vector<double> gas;
 
                std::vector<double> water;
            };
 
            Connate conn;
 
            Critical crit;
 
            Maximum smax;
        };
 
        struct Horizontal {
            static std::unique_ptr<EPSEvalInterface>
            fromECLOutput(const ECLGraph&          G,
                          const ECLInitFileData&   init,
                          const EPSOptions&        opt,
                          const RawTableEndPoints& tep);
 
            static std::vector<EPSEvalInterface::TableEndPoints>
            unscaledEndPoints(const EPSOptions&        opt,
                              const RawTableEndPoints& ep);
        };
 
        struct Vertical {
            using SatFuncEvaluator = std::function<double(int, double)>;
            using FuncValVector    = std::vector<
                VerticalScalingInterface::FunctionValues>;
 
            static std::unique_ptr<VerticalScalingInterface>
            fromECLOutput(const ECLGraph&          G,
                          const ECLInitFileData&   init,
                          const EPSOptions&        opt,
                          const RawTableEndPoints& tep,
                          const FuncValVector&     fvals);
 
            static std::vector<VerticalScalingInterface::FunctionValues>
            unscaledFunctionValues(const ECLGraph&          G,
                                   const ECLInitFileData&   init,
                                   const RawTableEndPoints& ep,
                                   const EPSOptions&        opt,
                                   const SatFuncEvaluator&  evalSF);
        };
    };
 
    std::vector<double>
    scaledConnateGas(const ECLGraph&                     G,
                     const ECLInitFileData&              init,
                     const CreateEPS::RawTableEndPoints& tep);
 
    std::vector<double>
    scaledConnateWater(const ECLGraph&                     G,
                       const ECLInitFileData&              init,
                       const CreateEPS::RawTableEndPoints& tep);
}} // namespace Opm::SatFunc
 
#endif // OPM_ECLENDPOINTSCALING_HEADER_INCLUDED