ReservoirPropertyCommon.hpp

Go to the documentation of this file.

//===========================================================================
//
// File: ReservoirPropertyCommon.hpp
//
// Created: Mon Oct 26 08:23:31 2009
//
// Author(s): Atgeirr F Rasmussen <atgeirr@sintef.no>
//            B�rd Skaflestad     <bard.skaflestad@sintef.no>
//
// $Date$
//
// $Revision$
//
//===========================================================================
 
/*
  Copyright 2009, 2010 SINTEF ICT, Applied Mathematics.
  Copyright 2009, 2010 Statoil ASA.
 
  This file is part of The Open Reservoir Simulator Project (OpenRS).
 
  OpenRS 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.
 
  OpenRS 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 OpenRS.  If not, see <http://www.gnu.org/licenses/>.
*/
 
#ifndef OPENRS_RESERVOIRPROPERTYCOMMON_HEADER
#define OPENRS_RESERVOIRPROPERTYCOMMON_HEADER
 
#include <opm/input/eclipse/Units/Units.hpp>
#include <opm/porsol/common/Matrix.hpp>
 
#include <opm/input/eclipse/Deck/Deck.hpp>
 
namespace Opm
{
 
 
 
    enum PermeabilityKind { ScalarPerm, DiagonalPerm, TensorPerm, None, Invalid };
 
 
 
 
    template <int dim, class RPImpl, class RockType>
    class ReservoirPropertyCommon
    {
    public:
        typedef ImmutableCMatrix PermTensor;
        typedef OwnCMatrix       MutablePermTensor;
        typedef SharedCMatrix    SharedPermTensor;
 
        enum { NumberOfPhases = 2 };
 
        ReservoirPropertyCommon();
 
        void init(const Opm::Deck&,
                  const std::vector<int>& global_cell,
                  const double perm_threshold = 0.0,
                  const std::string* rock_list_filename = 0,
                  const bool use_jfunction_scaling = true,
                  const double sigma = 1.0,
                  const double theta = 0.0);
 
        void init(const int num_cells,
                  const double uniform_poro = 0.2,
                  const double uniform_perm = 100.0*Opm::prefix::milli*Opm::unit::darcy);
 
        void setViscosities(double v1, double v2);
 
        void setDensities(double d1, double d2);
 
        double viscosityFirstPhase() const;
 
        double viscositySecondPhase() const;
 
        double densityFirstPhase() const;
 
        double densitySecondPhase() const;
 
        double porosity(int cell_index) const;
 
        double ntg(int cell_index) const;
 
        double swcr(int cell_index) const;
 
        double sowcr(int cell_index) const;
 
        PermTensor permeability(int cell_index) const;
 
    SharedPermTensor permeabilityModifiable(int cell_index);
 
        template<class Vector>
        void phaseDensities(int /*cell_index*/, Vector& density) const;
 
        double densityDifference() const;
 
        double cflFactor() const;
 
        double cflFactorGravity() const;
 
        double cflFactorCapillary() const;
 
        double capillaryPressure(int cell_index, double saturation) const;
        double capillaryPressureDeriv(int c, double s) const;
 
        // @brief Minimum of saturation in rock table.
        double s_min(int c) const;
 
        // @brief Maximum of saturation in rock table.
        double s_max(int c) const;
 
        double saturationFromCapillaryPressure(int cell_index, double cap_press) const;
 
        void writeSintefLegacyFormat(const std::string& grid_prefix) const;
 
    protected:
    // Methods
        void assignPorosity(const Opm::Deck& deck,
                            const std::vector<int>& global_cell);
        void assignNTG(const Opm::Deck& deck,
                       const std::vector<int>& global_cell);
        void assignSWCR(const Opm::Deck& deck,
                        const std::vector<int>& global_cell);
        void assignSOWCR(const Opm::Deck& deck,
                         const std::vector<int>& global_cell);
        void assignPermeability(const Opm::Deck& deck,
                                const std::vector<int>& global_cell,
                                const double perm_threshold);
        void assignRockTable(const Opm::Deck& deck,
                             const std::vector<int>& global_cell);
        void readRocks(const std::string& rock_list_file);
 
    // Supporting Barton/Nackman trick (also known as the curiously recurring template pattern).
    RPImpl& asImpl();
 
    // Data members.
        std::vector<double>        porosity_;
        std::vector<double>        ntg_;
        std::vector<double>        swcr_;
        std::vector<double>        sowcr_;
        std::vector<double>        permeability_;
        std::vector<unsigned char> permfield_valid_;
        double density1_;
        double density2_;
        double viscosity1_;
        double viscosity2_;
        double cfl_factor_;
        double cfl_factor_gravity_;
        double cfl_factor_capillary_;
        std::vector<RockType> rock_;
        std::vector<int> cell_to_rock_;
        PermeabilityKind permeability_kind_;
    };
 
 
} // namespace Opm
 
#include "ReservoirPropertyCommon_impl.hpp"
 
#endif // OPENRS_RESERVOIRPROPERTYCOMMON_HEADER