From 3d73bd3c72371701be29d2f524d393c5b716d56e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Atgeirr=20Fl=C3=B8=20Rasmussen?= Date: Fri, 9 Jan 2015 13:23:01 +0100 Subject: [PATCH] Add IncompPropertiesSinglePhase class. --- CMakeLists_files.cmake | 2 + .../props/IncompPropertiesSinglePhase.cpp | 178 ++++++++++++++++++ .../props/IncompPropertiesSinglePhase.hpp | 146 ++++++++++++++ 3 files changed, 326 insertions(+) create mode 100644 opm/core/props/IncompPropertiesSinglePhase.cpp create mode 100644 opm/core/props/IncompPropertiesSinglePhase.hpp diff --git a/CMakeLists_files.cmake b/CMakeLists_files.cmake index 149f73f9..389f7818 100644 --- a/CMakeLists_files.cmake +++ b/CMakeLists_files.cmake @@ -83,6 +83,7 @@ list (APPEND MAIN_SOURCE_FILES opm/core/props/BlackoilPropertiesFromDeck.cpp opm/core/props/IncompPropertiesBasic.cpp opm/core/props/IncompPropertiesFromDeck.cpp + opm/core/props/IncompPropertiesSinglePhase.cpp opm/core/props/pvt/BlackoilPvtProperties.cpp opm/core/props/pvt/PvtPropertiesBasic.cpp opm/core/props/pvt/PvtPropertiesIncompFromDeck.cpp @@ -335,6 +336,7 @@ list (APPEND PUBLIC_HEADER_FILES opm/core/props/IncompPropertiesInterface.hpp opm/core/props/IncompPropertiesShadow.hpp opm/core/props/IncompPropertiesShadow_impl.hpp + opm/core/props/IncompPropertiesSinglePhase.hpp opm/core/props/phaseUsageFromDeck.hpp opm/core/props/pvt/BlackoilPvtProperties.hpp opm/core/props/pvt/PvtPropertiesBasic.hpp diff --git a/opm/core/props/IncompPropertiesSinglePhase.cpp b/opm/core/props/IncompPropertiesSinglePhase.cpp new file mode 100644 index 00000000..e56ed32e --- /dev/null +++ b/opm/core/props/IncompPropertiesSinglePhase.cpp @@ -0,0 +1,178 @@ +/* + 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 . +*/ + + +#include "config.h" + +#include +#include +#include +#include +// #include + +namespace Opm +{ + IncompPropertiesSinglePhase::IncompPropertiesSinglePhase(Opm::DeckConstPtr deck, + Opm::EclipseStateConstPtr eclState, + const UnstructuredGrid& grid) + { + rock_.init(eclState, grid.number_of_cells, grid.global_cell, grid.cartdims); + + if (deck->hasKeyword("DENSITY")) { + Opm::DeckRecordConstPtr densityRecord = deck->getKeyword("DENSITY")->getRecord(0); + surface_density_ = densityRecord->getItem("OIL")->getSIDouble(0); + } else { + surface_density_ = 1000.0; + OPM_MESSAGE("Input is missing DENSITY -- using a standard density of " + << surface_density_ << ".\n"); + } + + // This will be modified if we have a PVCDO specification. + reservoir_density_ = surface_density_; + + if (deck->hasKeyword("PVCDO")) { + Opm::DeckRecordConstPtr pvcdoRecord = deck->getKeyword("PVCDO")->getRecord(0); + if (pvcdoRecord->getItem("OIL_COMPRESSIBILITY")->getSIDouble(0) != 0.0 || + pvcdoRecord->getItem("OIL_VISCOSIBILITY")->getSIDouble(0) != 0.0) { + OPM_MESSAGE("Compressibility effects in PVCDO are ignored."); + } + reservoir_density_ /= pvcdoRecord->getItem("OIL_VOL_FACTOR")->getSIDouble(0); + viscosity_ = pvcdoRecord->getItem("OIL_VISCOSITY")->getSIDouble(0); + } else { + viscosity_ = 1.0 * prefix::centi*unit::Poise; + OPM_MESSAGE("Input is missing PVCDO -- using a standard viscosity of " + << viscosity_ << " and reservoir density equal to surface density.\n"); + } + } + + IncompPropertiesSinglePhase::~IncompPropertiesSinglePhase() + { + } + + + /// \return D, the number of spatial dimensions. + int IncompPropertiesSinglePhase::numDimensions() const + { + return rock_.numDimensions(); + } + + /// \return N, the number of cells. + int IncompPropertiesSinglePhase::numCells() const + { + return rock_.numCells(); + } + + /// \return Array of N porosity values. + const double* IncompPropertiesSinglePhase::porosity() const + { + return rock_.porosity(); + } + + /// \return Array of ND^2 permeability values. + /// The D^2 permeability values for a cell are organized as a matrix, + /// which is symmetric (so ordering does not matter). + const double* IncompPropertiesSinglePhase::permeability() const + { + return rock_.permeability(); + } + + + // ---- Fluid interface ---- + + /// \return P, the number of phases (also the number of components). + int IncompPropertiesSinglePhase::numPhases() const + { + return 1; + } + + /// \return Array of P viscosity values. + const double* IncompPropertiesSinglePhase::viscosity() const + { + return &viscosity_; + } + + /// \return Array of P density values. + const double* IncompPropertiesSinglePhase::density() const + { + return &reservoir_density_; + } + + /// \return Array of P density values. + const double* IncompPropertiesSinglePhase::surfaceDensity() const + { + return &surface_density_; + } + + /// Relative permeability. Always returns 1 (and 0 for derivatives). + /// \param[in] n Number of data points. + /// \param[in] s Array of n saturation values. + /// \param[in] cells Array of n cell indices to be associated with the s values. + /// \param[out] kr Array of n relperm values, array must be valid before calling. + /// \param[out] dkrds If non-null: array of n relperm derivative values, + /// array must be valid before calling. + void IncompPropertiesSinglePhase::relperm(const int n, + const double* /* s */, + const int* /* cells */, + double* kr, + double* dkrds) const + { + std::fill(kr, kr + n, 1.0); + if (dkrds) { + std::fill(dkrds, dkrds + n, 0.0); + } + } + + + /// Capillary pressure. Always returns zero. + /// \param[in] n Number of data points. + /// \param[in] s Array of n saturation values. + /// \param[in] cells Array of n cell indices to be associated with the s values. + /// \param[out] pc Array of n capillary pressure values, array must be valid before calling. + /// \param[out] dpcds If non-null: array of n derivative values, + /// array must be valid before calling. + void IncompPropertiesSinglePhase::capPress(const int n, + const double* /* s */, + const int* /* cells */, + double* pc, + double* dpcds) const + { + std::fill(pc, pc + n, 0.0); + if (dpcds) { + std::fill(dpcds, dpcds + n, 0.0); + } + } + + + /// Obtain the range of allowable saturation values. + /// Saturation range is just the point 1 for this class + /// \param[in] n Number of data points. + /// \param[in] cells Array of n cell indices. + /// \param[out] smin Array of n minimum s values, array must be valid before calling. + /// \param[out] smax Array of n maximum s values, array must be valid before calling. + void IncompPropertiesSinglePhase::satRange(const int n, + const int* /* cells */, + double* smin, + double* smax) const + { + std::fill(smin, smin + n, 1.0); + std::fill(smax, smax + n, 1.0); + } + +} // namespace Opm + diff --git a/opm/core/props/IncompPropertiesSinglePhase.hpp b/opm/core/props/IncompPropertiesSinglePhase.hpp new file mode 100644 index 00000000..0be6df08 --- /dev/null +++ b/opm/core/props/IncompPropertiesSinglePhase.hpp @@ -0,0 +1,146 @@ +/* + 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 . +*/ + +#ifndef OPM_INCOMPPROPERTIESSINGLEPHASE_HEADER_INCLUDED +#define OPM_INCOMPPROPERTIESSINGLEPHASE_HEADER_INCLUDED + + + +#include +#include +#include +#include + +struct UnstructuredGrid; + +namespace Opm +{ + + /// Concrete class implementing the incompressible property + /// interface for a simplified single-phase setting, reading all + /// data and properties from eclipse deck input. The oil phase + /// properties are used where applicable and available. + /// + /// Supports variable number of spatial dimensions, called D. + /// Supports a single phase only. + /// In general, when arguments call for n values of some vector or + /// matrix property, such as saturation, they shall always be + /// ordered cellwise: + /// [s^1_0 s^2_0 s^3_0 s^1_1 s^2_2 ... ] + /// in which s^i_j denotes saturation of phase i in cell j. + class IncompPropertiesSinglePhase : public IncompPropertiesInterface + { + public: + /// Initialize from deck and grid. + /// \param deck Deck input parser + /// \param eclState The EclipseState (processed deck) produced by the opm-parser code + /// \param grid Grid to which property object applies, needed for the + /// mapping from cell indices (typically from a processed grid) + /// to logical cartesian indices consistent with the deck. + IncompPropertiesSinglePhase(Opm::DeckConstPtr deck, + Opm::EclipseStateConstPtr eclState, + const UnstructuredGrid& grid); + + /// Destructor. + virtual ~IncompPropertiesSinglePhase(); + + // ---- Rock interface ---- + + /// \return D, the number of spatial dimensions. + virtual int numDimensions() const; + + /// \return N, the number of cells. + virtual int numCells() const; + + /// \return Array of N porosity values. + virtual const double* porosity() const; + + /// \return Array of ND^2 permeability values. + /// The D^2 permeability values for a cell are organized as a matrix, + /// which is symmetric (so ordering does not matter). + virtual const double* permeability() const; + + + // ---- Fluid interface ---- + + /// \return P, the number of phases (= 1). + virtual int numPhases() const; + + /// \return Array of P (= 1) viscosity values. + virtual const double* viscosity() const; + + /// Densities of fluid at reservoir conditions. + /// \return Array of P (= 1) density values. + virtual const double* density() const; + + /// Densities of fluid phases at surface conditions. + /// \return Array of P (= 1) density values. + virtual const double* surfaceDensity() const; + + /// Relative permeability. Always returns 1 (and 0 for derivatives). + /// \param[in] n Number of data points. + /// \param[in] s Array of n saturation values. + /// \param[in] cells Array of n cell indices to be associated with the s values. + /// \param[out] kr Array of n relperm values, array must be valid before calling. + /// \param[out] dkrds If non-null: array of n relperm derivative values, + /// array must be valid before calling. + virtual void relperm(const int n, + const double* s, + const int* cells, + double* kr, + double* dkrds) const; + + /// Capillary pressure. Always returns zero. + /// \param[in] n Number of data points. + /// \param[in] s Array of n saturation values. + /// \param[in] cells Array of n cell indices to be associated with the s values. + /// \param[out] pc Array of n capillary pressure values, array must be valid before calling. + /// \param[out] dpcds If non-null: array of n derivative values, + /// array must be valid before calling. + virtual void capPress(const int n, + const double* s, + const int* cells, + double* pc, + double* dpcds) const; + + + /// Obtain the range of allowable saturation values. + /// Saturation range is just the point 1 for this class + /// \param[in] n Number of data points. + /// \param[in] cells Array of n cell indices. + /// \param[out] smin Array of n minimum s values, array must be valid before calling. + /// \param[out] smax Array of n maximum s values, array must be valid before calling. + virtual void satRange(const int n, + const int* cells, + double* smin, + double* smax) const; + private: + RockFromDeck rock_; + double surface_density_; + double reservoir_density_; + double viscosity_; + }; + + + +} // namespace Opm + + + +#endif // OPM_INCOMPPROPERTIESSINGLEPHASE_HEADER_INCLUDED