RelPermUtils.hpp

Go to the documentation of this file.

/*
  Copyright 2010 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_UPSCALING_RELPERM_UTILS_HPP
#define OPM_UPSCALING_RELPERM_UTILS_HPP
 
#include <opm/input/eclipse/Parser/Parser.hpp>
#include <opm/input/eclipse/Deck/Deck.hpp>
 
#include <opm/common/utility/numeric/MonotCubicInterpolator.hpp>
 
#include <opm/upscaling/ParserAdditions.hpp>
#include <opm/upscaling/SinglePhaseUpscaler.hpp>
 
#include <array>
#include <map>
#include <memory>
#include <tuple>
#include <vector>
 
namespace Opm {
  double getVoigtValue(const SinglePhaseUpscaler::permtensor_t& K, int voigt_idx);
 
  void setVoigtValue(SinglePhaseUpscaler::permtensor_t& K, int voigt_idx, double val);
 
  class RelPermUpscaleHelper {
    public:
      bool isMaster;                               
      bool doEclipseCheck;                         
      bool anisotropic_input;                      
      int points;                                  
      int tensorElementCount;                      
      bool upscaleBothPhases;                      
      std::vector<double> WaterSaturation;         
      SinglePhaseUpscaler::permtensor_t permTensor; 
      std::vector<int> satnums;                    
      std::vector<MonotCubicInterpolator> InvJfunctions; 
      std::array<std::array<std::vector<MonotCubicInterpolator>,2>,3> Krfunctions;
      SinglePhaseUpscaler::BoundaryConditionType boundaryCondition; 
      std::vector<MonotCubicInterpolator> SwPcfunctions; 
      std::string saturationstring; 
      size_t tesselatedCells; 
      double volume; 
      double poreVolume; 
      std::vector<double> pressurePoints; 
 
      template <class String>
      static Deck
      parseEclipseFile(const String& eclipseFileName);
 
      RelPermUpscaleHelper(int mpi_rank, std::map<std::string,std::string>& options_);
 
      void collectResults();
 
      std::vector<std::vector<double>> getRelPerm(int phase) const;
 
      void upscaleSinglePhasePermeability();
 
      void sanityCheckInput(const Opm::Deck& deck,
                            const double      minPerm,
                            const double      maxPerm,
                            const double      minPoro);
 
      void checkCriticalSaturations();
 
      void setupBoundaryConditions();
 
      double tesselateGrid(const Opm::Deck& deck);
 
      void calculateCellPressureGradients();
 
      void calculateMinMaxCapillaryPressure();
 
      void upscaleCapillaryPressure();
 
      std::tuple<double,double> upscalePermeability(int mpi_rank);
 
    private:
      bool checkCurve(MonotCubicInterpolator& func);
 
      double Swir; 
      double Swor; 
      double Pcmin; 
      double Pcmax; 
      double critRelpThresh; 
      std::vector<int> node_vs_pressurepoint; 
      std::array<std::vector<std::vector<double>>,2> PhasePerm; 
      SinglePhaseUpscaler::permtensor_t permTensorInv; 
      SinglePhaseUpscaler upscaler; 
      std::array<std::vector<double>,3> perms; 
      std::vector<double> poros; 
      std::vector<double> zcorns; 
      double minSinglePhasePerm; 
      std::vector<double> cellPoreVolumes; 
      MonotCubicInterpolator WaterSaturationVsCapPressure; 
 
#if defined(UNITTEST_TRESPASS_PRIVATE_PROPERTY_DP)
    public: // Intrusive unit testing of calculcateCellPressureGradients()
#endif // UNITTEST_TRESPASS_PRIVATE_PROPERTY_DP
      std::vector<double> dP; 
 
#if defined(UNITTEST_TRESPASS_PRIVATE_PROPERTY_DP)
    private:
#endif // UNITTEST_TRESPASS_PRIVATE_PROPERTY_DP
 
      std::map<std::string,std::string>& options; 
  };
 
  template <class String>
  Deck
  RelPermUpscaleHelper::parseEclipseFile(const String& eclipseFileName)
  {
    auto parser = Parser{};
    addNonStandardUpscalingKeywords(parser);
 
    return parser.parseFile(eclipseFileName);
  }
}
 
#endif  // OPM_UPSCALING_RELPERM_UTILS_HPP