VFPHelpers.hpp

Go to the documentation of this file.

/*
  Copyright 2015 SINTEF ICT, Applied Mathematics.
 
  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_AUTODIFF_VFPHELPERS_HPP_
#define OPM_AUTODIFF_VFPHELPERS_HPP_
 
#include <array>
#include <functional>
#include <map>
#include <vector>
#include <optional>
 
namespace Opm {
 
class VFPInjTable;
class VFPProdTable;
 
namespace detail {
 
template <typename T>
T getFlo(const VFPProdTable& table,
         const T& aqua,
         const T& liquid,
         const T& vapour);
 
template <typename T>
T getFlo(const VFPInjTable& table,
         const T& aqua,
         const T& liquid,
         const T& vapour);
 
template <typename T>
T getWFR(const VFPProdTable& table,
         const T& aqua,
         const T& liquid,
         const T& vapour);
 
template <typename T>
T getGFR(const VFPProdTable& table,
         const T& aqua,
         const T& liquid,
         const T& vapour);
 
struct InterpData {
    InterpData() : ind_{0, 0}, inv_dist_(0.0), factor_(0.0) {}
    int ind_[2]; //[First element greater than or equal to value, Last element smaller than or equal to value]
    double inv_dist_; // 1 / distance between the two end points of the segment. Used to calculate derivatives and uses 1.0 / 0.0 = 0.0 as a convention
    double factor_; // Interpolation factor
};
 
InterpData findInterpData(const double value_in, const std::vector<double>& values);
 
struct VFPEvaluation {
    VFPEvaluation() : value(0.0), dthp(0.0), dwfr(0.0), dgfr(0.0), dalq(0.0), dflo(0.0) {};
    double value;
    double dthp;
    double dwfr;
    double dgfr;
    double dalq;
    double dflo;
};
 
VFPEvaluation operator+(VFPEvaluation lhs, const VFPEvaluation& rhs);
VFPEvaluation operator-(VFPEvaluation lhs, const VFPEvaluation& rhs);
VFPEvaluation operator*(double lhs, const VFPEvaluation& rhs);
 
VFPEvaluation interpolate(const VFPProdTable& table,
                          const InterpData& flo_i,
                          const InterpData& thp_i,
                          const InterpData& wfr_i,
                          const InterpData& gfr_i,
                          const InterpData& alq_i);
 
VFPEvaluation interpolate(const VFPInjTable& table,
                          const InterpData& flo_i,
                          const InterpData& thp_i);
 
VFPEvaluation bhp(const VFPProdTable& table,
                  const double aqua,
                  const double liquid,
                  const double vapour,
                  const double thp,
                  const double alq,
                  const double explicit_wfr,
                  const double explicit_gfr,
                  const bool   use_vfpexplicit);
 
VFPEvaluation bhp(const VFPInjTable& table,
                  const double aqua,
                  const double liquid,
                  const double vapour,
                  const double thp);
 
 
template <typename T>
const T& getTable(const std::map<int, std::reference_wrapper<const T>>& tables, int table_id);
 
template <typename T>
bool hasTable(const std::map<int, std::reference_wrapper<const T>>& tables, int table_id) {
    const auto entry = tables.find(table_id);
    return (entry != tables.end() );
}
 
 
template <typename TYPE, typename TABLE>
TYPE getType(const TABLE& table);
 
 
double findTHP(const std::vector<double>& bhp_array,
               const std::vector<double>& thp_array,
               double bhp);
 
std::pair<double, double> 
getMinimumBHPCoordinate(const VFPProdTable& table,
                        const double thp,
                        const double wfr,
                        const double gfr,
                        const double alq);
 
std::optional<std::pair<double, double>> 
intersectWithIPR(const VFPProdTable& table,
                 const double thp,
                 const double wfr,
                 const double gfr,
                 const double alq, 
                 const double ipr_a,
                 const double ipr_b,
                 const std::function<double(const double)>& adjust_bhp);                        
 
} // namespace detail
 
 
} // namespace
 
 
 
 
#endif /* OPM_AUTODIFF_VFPHELPERS_HPP_ */