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/core/utility/MonotCubicInterpolator.hpp>
#include <opm/upscaling/SinglePhaseUpscaler.hpp>
#include <array>
#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; 

      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(Opm::DeckConstPtr deck,
                            double minPerm, double maxPerm, double minPoro);

      void checkCriticalSaturations();

      void setupBoundaryConditions();

      double tesselateGrid(Opm::DeckConstPtr deck);

      void calculateCellPressureGradients(const std::array<int,3>& res);

      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; 

      // Reference: http://www.spe.org/spe-site/spe/spe/papers/authors/Metric_Standard.pdf
      const double milliDarcyToSqMetre; 

      std::vector<double> dP; 
      std::map<std::string,std::string>& options; 
  };
}

#endif