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/core/utility/Units.hpp>
#include <opm/porsol/common/Matrix.hpp>

#include <opm/parser/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(Opm::DeckConstPtr 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(Opm::DeckConstPtr deck,
                            const std::vector<int>& global_cell);
        void assignNTG(Opm::DeckConstPtr deck,
                       const std::vector<int>& global_cell);
        void assignSWCR(Opm::DeckConstPtr deck,
                        const std::vector<int>& global_cell);
        void assignSOWCR(Opm::DeckConstPtr deck,
                         const std::vector<int>& global_cell);
        void assignPermeability(Opm::DeckConstPtr deck,
                                const std::vector<int>& global_cell,
                                const double perm_threshold);
        void assignRockTable(Opm::DeckConstPtr 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