My Project
EclMaterialLawManager.hpp
Go to the documentation of this file.
1// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
2// vi: set et ts=4 sw=4 sts=4:
3/*
4 This file is part of the Open Porous Media project (OPM).
5
6 OPM is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 2 of the License, or
9 (at your option) any later version.
10
11 OPM is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with OPM. If not, see <http://www.gnu.org/licenses/>.
18
19 Consult the COPYING file in the top-level source directory of this
20 module for the precise wording of the license and the list of
21 copyright holders.
22*/
27#if ! HAVE_ECL_INPUT
28#error "Eclipse input support in opm-common is required to use the ECL material manager!"
29#endif
30
31#ifndef OPM_ECL_MATERIAL_LAW_MANAGER_HPP
32#define OPM_ECL_MATERIAL_LAW_MANAGER_HPP
33
34#include <opm/input/eclipse/EclipseState/Grid/FaceDir.hpp>
35
42#include <opm/input/eclipse/EclipseState/Tables/TableColumn.hpp>
43#include <opm/input/eclipse/EclipseState/EclipseState.hpp>
44
45#include <cassert>
46#include <memory>
47#include <tuple>
48#include <vector>
49
50namespace Opm {
51
52class EclipseState;
53class EclEpsConfig;
54class EclEpsGridProperties;
55template<class Scalar> class EclEpsScalingPoints;
56template<class Scalar> struct EclEpsScalingPointsInfo;
57class EclHysteresisConfig;
58enum class EclTwoPhaseSystemType;
59class Runspec;
60class SgfnTable;
61class SgofTable;
62class SlgofTable;
63
70template <class TraitsT>
72{
73private:
74 using Traits = TraitsT;
75 using Scalar = typename Traits::Scalar;
76 enum { waterPhaseIdx = Traits::wettingPhaseIdx };
77 enum { oilPhaseIdx = Traits::nonWettingPhaseIdx };
78 enum { gasPhaseIdx = Traits::gasPhaseIdx };
79 enum { numPhases = Traits::numPhases };
80
84
85 // the two-phase material law which is defined on effective (unscaled) saturations
89
90 using GasOilEffectiveTwoPhaseParams = typename GasOilEffectiveTwoPhaseLaw::Params;
91 using OilWaterEffectiveTwoPhaseParams = typename OilWaterEffectiveTwoPhaseLaw::Params;
92 using GasWaterEffectiveTwoPhaseParams = typename GasWaterEffectiveTwoPhaseLaw::Params;
93
94 // the two-phase material law which is defined on absolute (scaled) saturations
98 using GasOilEpsTwoPhaseParams = typename GasOilEpsTwoPhaseLaw::Params;
99 using OilWaterEpsTwoPhaseParams = typename OilWaterEpsTwoPhaseLaw::Params;
100 using GasWaterEpsTwoPhaseParams = typename GasWaterEpsTwoPhaseLaw::Params;
101
102 // the scaled two-phase material laws with hystersis
106 using GasOilTwoPhaseHystParams = typename GasOilTwoPhaseLaw::Params;
107 using OilWaterTwoPhaseHystParams = typename OilWaterTwoPhaseLaw::Params;
108 using GasWaterTwoPhaseHystParams = typename GasWaterTwoPhaseLaw::Params;
109
110public:
111 // the three-phase material law used by the simulation
113 using MaterialLawParams = typename MaterialLaw::Params;
114 using DirectionalMaterialLawParamsPtr = std::unique_ptr<DirectionalMaterialLawParams<MaterialLawParams>>;
115
118
119private:
120 // internal typedefs
121 using GasOilEffectiveParamVector = std::vector<std::shared_ptr<GasOilEffectiveTwoPhaseParams>>;
122 using OilWaterEffectiveParamVector = std::vector<std::shared_ptr<OilWaterEffectiveTwoPhaseParams>>;
123 using GasWaterEffectiveParamVector = std::vector<std::shared_ptr<GasWaterEffectiveTwoPhaseParams>>;
124
125 using GasOilScalingPointsVector = std::vector<std::shared_ptr<EclEpsScalingPoints<Scalar>>>;
126 using OilWaterScalingPointsVector = std::vector<std::shared_ptr<EclEpsScalingPoints<Scalar>>>;
127 using GasWaterScalingPointsVector = std::vector<std::shared_ptr<EclEpsScalingPoints<Scalar>>>;
128 using OilWaterScalingInfoVector = std::vector<EclEpsScalingPointsInfo<Scalar>>;
129 using GasOilParamVector = std::vector<std::shared_ptr<GasOilTwoPhaseHystParams>>;
130 using OilWaterParamVector = std::vector<std::shared_ptr<OilWaterTwoPhaseHystParams>>;
131 using GasWaterParamVector = std::vector<std::shared_ptr<GasWaterTwoPhaseHystParams>>;
132 using MaterialLawParamsVector = std::vector<std::shared_ptr<MaterialLawParams>>;
133
134 // helper classes
135
136 // This class' implementation is defined in "EclMaterialLawManagerInitParams.cpp"
137 class InitParams {
138 public:
139 InitParams(EclMaterialLawManager<TraitsT>& parent, const EclipseState& eclState, size_t numCompressedElems);
140 void run();
141 private:
142 class HystParams;
143 void copySatnumArrays_();
144 void copyIntArray_(std::vector<int>& dest, const std::string keyword);
145 unsigned imbRegion_(std::vector<int>& array, unsigned elemIdx);
146 void initArrays_(
147 std::vector<std::vector<int>*>& satnumArray,
148 std::vector<std::vector<int>*>& imbnumArray,
149 std::vector<std::vector<MaterialLawParams>*>& mlpArray);
150 void initMaterialLawParamVectors_();
151 void initOilWaterScaledEpsInfo_();
152 void initSatnumRegionArray_();
153 void initThreePhaseParams_(
154 HystParams &hystParams,
155 MaterialLawParams& materialParams,
156 unsigned satRegionIdx,
157 unsigned elemIdx);
158 void readEffectiveParameters_();
159 void readUnscaledEpsPointsVectors_();
160 template <class Container>
161 void readUnscaledEpsPoints_(Container& dest, std::shared_ptr<EclEpsConfig> config, EclTwoPhaseSystemType system_type);
162 unsigned satRegion_(std::vector<int>& array, unsigned elemIdx);
163 unsigned satOrImbRegion_(std::vector<int>& array, std::vector<int>& default_vec, unsigned elemIdx);
164
165 // This class' implementation is defined in "EclMaterialLawManagerHystParams.cpp"
166 class HystParams {
167 public:
168 HystParams(EclMaterialLawManager<TraitsT>::InitParams& init_params);
169 void finalize();
170 std::shared_ptr<GasOilTwoPhaseHystParams> getGasOilParams();
171 std::shared_ptr<OilWaterTwoPhaseHystParams> getOilWaterParams();
172 std::shared_ptr<GasWaterTwoPhaseHystParams> getGasWaterParams();
173 void setConfig();
174 void setDrainageParamsOilGas(unsigned elemIdx, unsigned satRegionIdx);
175 void setDrainageParamsOilWater(unsigned elemIdx, unsigned satRegionIdx);
176 void setDrainageParamsGasWater(unsigned elemIdx, unsigned satRegionIdx);
177 void setImbibitionParamsOilGas(unsigned elemIdx, unsigned satRegionIdx);
178 void setImbibitionParamsOilWater(unsigned elemIdx, unsigned satRegionIdx);
179 void setImbibitionParamsGasWater(unsigned elemIdx, unsigned satRegionIdx);
180 private:
181 bool hasGasWater_();
182 bool hasGasOil_();
183 bool hasOilWater_();
184
185 std::tuple<EclEpsScalingPointsInfo<Scalar>, EclEpsScalingPoints<Scalar>> readScaledEpsPoints_(
186 const EclEpsGridProperties& epsGridProperties, unsigned elemIdx, EclTwoPhaseSystemType type);
187 std::tuple<EclEpsScalingPointsInfo<Scalar>, EclEpsScalingPoints<Scalar>>
188 readScaledEpsPointsDrainage_(unsigned elemIdx, EclTwoPhaseSystemType type);
189 std::tuple<EclEpsScalingPointsInfo<Scalar>, EclEpsScalingPoints<Scalar>>
190 readScaledEpsPointsImbibition_(unsigned elemIdx, EclTwoPhaseSystemType type);
193 const EclipseState& eclState_;
194 std::shared_ptr<GasOilTwoPhaseHystParams> gasOilParams_;
195 std::shared_ptr<OilWaterTwoPhaseHystParams> oilWaterParams_;
196 std::shared_ptr<GasWaterTwoPhaseHystParams> gasWaterParams_;
197 };
198
199 // This class' implementation is defined in "EclMaterialLawManagerReadEffectiveParams.cpp"
200 class ReadEffectiveParams {
201 public:
202 ReadEffectiveParams(EclMaterialLawManager<TraitsT>::InitParams& init_params);
203 void read();
204 private:
205 std::vector<double> normalizeKrValues_(const double tolcrit, const TableColumn& krValues) const;
206 void readGasOilParameters_(GasOilEffectiveParamVector& dest, unsigned satRegionIdx);
207 template <class TableType>
208 void readGasOilFamily2_(
209 GasOilEffectiveTwoPhaseParams& effParams,
210 const Scalar Swco,
211 const double tolcrit,
212 const TableType& sofTable,
213 const SgfnTable& sgfnTable,
214 const std::string& columnName);
215 void readGasOilSgof_(GasOilEffectiveTwoPhaseParams& effParams,
216 const Scalar Swco,
217 const double tolcrit,
218 const SgofTable& sgofTable);
219
220 void readGasOilSlgof_(GasOilEffectiveTwoPhaseParams& effParams,
221 const Scalar Swco,
222 const double tolcrit,
223 const SlgofTable& slgofTable);
224 void readGasWaterParameters_(GasWaterEffectiveParamVector& dest, unsigned satRegionIdx);
225 void readOilWaterParameters_(OilWaterEffectiveParamVector& dest, unsigned satRegionIdx);
226
229 const EclipseState& eclState_;
230 }; // end of "class ReadEffectiveParams"
231
233 const EclipseState& eclState_;
234 size_t numCompressedElems_;
235
236 std::unique_ptr<EclEpsGridProperties> epsImbGridProperties_; //imbibition
237 std::unique_ptr<EclEpsGridProperties> epsGridProperties_; // drainage
238
239 }; // end of "class InitParams"
240
241public:
242 void initFromState(const EclipseState& eclState);
243
244 void initParamsForElements(const EclipseState& eclState, size_t numCompressedElems);
245
254 Scalar applySwatinit(unsigned elemIdx,
255 Scalar pcow,
256 Scalar Sw);
257
258 bool enableEndPointScaling() const
259 { return enableEndPointScaling_; }
260
261 bool enableHysteresis() const
262 { return hysteresisConfig_->enableHysteresis(); }
263
264 MaterialLawParams& materialLawParams(unsigned elemIdx)
265 {
266 assert(elemIdx < materialLawParams_.size());
267 return materialLawParams_[elemIdx];
268 }
269
270 const MaterialLawParams& materialLawParams(unsigned elemIdx) const
271 {
272 assert(elemIdx < materialLawParams_.size());
273 return materialLawParams_[elemIdx];
274 }
275
276 const MaterialLawParams& materialLawParams(unsigned elemIdx, FaceDir::DirEnum facedir) const
277 {
278 return materialLawParamsFunc_(elemIdx, facedir);
279 }
280
281 MaterialLawParams& materialLawParams(unsigned elemIdx, FaceDir::DirEnum facedir)
282 {
283 return const_cast<MaterialLawParams&>(materialLawParamsFunc_(elemIdx, facedir));
284 }
285
294 const MaterialLawParams& connectionMaterialLawParams(unsigned satRegionIdx, unsigned elemIdx) const;
295
296 int satnumRegionIdx(unsigned elemIdx) const
297 { return satnumRegionArray_[elemIdx]; }
298
299 int getKrnumSatIdx(unsigned elemIdx, FaceDir::DirEnum facedir) const;
300
301 bool hasDirectionalRelperms() const
302 {
303 return !krnumXArray_.empty() || !krnumYArray_.empty() || !krnumZArray_.empty();
304 }
305
306 bool hasDirectionalImbnum() const {
307 if (imbnumXArray_.size() > 0 || imbnumYArray_.size() > 0 || imbnumZArray_.size() > 0) {
308 return true;
309 }
310 return false;
311 }
312
313 int imbnumRegionIdx(unsigned elemIdx) const
314 { return imbnumRegionArray_[elemIdx]; }
315
316 template <class FluidState>
317 void updateHysteresis(const FluidState& fluidState, unsigned elemIdx)
318 {
319 if (!enableHysteresis())
320 return;
321
322 MaterialLaw::updateHysteresis(materialLawParams(elemIdx), fluidState);
323 if (hasDirectionalRelperms() || hasDirectionalImbnum()) {
324 using Dir = FaceDir::DirEnum;
325 constexpr int ndim = 3;
326 Dir facedirs[ndim] = {Dir::XPlus, Dir::YPlus, Dir::ZPlus};
327 for (int i = 0; i<ndim; i++) {
328 MaterialLaw::updateHysteresis(materialLawParams(elemIdx, facedirs[i]), fluidState);
329 }
330 }
331 }
332
333 void oilWaterHysteresisParams(Scalar& pcSwMdc,
334 Scalar& krnSwMdc,
335 unsigned elemIdx) const;
336
337 void setOilWaterHysteresisParams(const Scalar& pcSwMdc,
338 const Scalar& krnSwMdc,
339 unsigned elemIdx);
340
341 void gasOilHysteresisParams(Scalar& pcSwMdc,
342 Scalar& krnSwMdc,
343 unsigned elemIdx) const;
344
345 void setGasOilHysteresisParams(const Scalar& pcSwMdc,
346 const Scalar& krnSwMdc,
347 unsigned elemIdx);
348
349 EclEpsScalingPoints<Scalar>& oilWaterScaledEpsPointsDrainage(unsigned elemIdx);
350
351 const EclEpsScalingPointsInfo<Scalar>& oilWaterScaledEpsInfoDrainage(size_t elemIdx) const
352 { return oilWaterScaledEpsInfoDrainage_[elemIdx]; }
353
354 template<class Serializer>
355 void serializeOp(Serializer& serializer)
356 {
357 // This is for restart serialization.
358 // Only dynamic state in the parameters need to be stored.
359 // For that reason we do not serialize the vector
360 // as that would recreate the objects inside.
361 for (auto& mat : materialLawParams_) {
362 serializer(mat);
363 }
364 }
365
366private:
367 const MaterialLawParams& materialLawParamsFunc_(unsigned elemIdx, FaceDir::DirEnum facedir) const;
368
369 void readGlobalEpsOptions_(const EclipseState& eclState);
370
371 void readGlobalHysteresisOptions_(const EclipseState& state);
372
373 void readGlobalThreePhaseOptions_(const Runspec& runspec);
374
375 bool enableEndPointScaling_;
376 std::shared_ptr<EclHysteresisConfig> hysteresisConfig_;
377
378 std::shared_ptr<EclEpsConfig> oilWaterEclEpsConfig_;
379 std::vector<EclEpsScalingPointsInfo<Scalar>> unscaledEpsInfo_;
380 OilWaterScalingInfoVector oilWaterScaledEpsInfoDrainage_;
381
382 std::shared_ptr<EclEpsConfig> gasWaterEclEpsConfig_;
383
384 GasOilScalingPointsVector gasOilUnscaledPointsVector_;
385 OilWaterScalingPointsVector oilWaterUnscaledPointsVector_;
386 GasWaterScalingPointsVector gasWaterUnscaledPointsVector_;
387
388 GasOilEffectiveParamVector gasOilEffectiveParamVector_;
389 OilWaterEffectiveParamVector oilWaterEffectiveParamVector_;
390 GasWaterEffectiveParamVector gasWaterEffectiveParamVector_;
391
392 EclMultiplexerApproach threePhaseApproach_ = EclMultiplexerApproach::Default;
393 // this attribute only makes sense for twophase simulations!
394 enum EclTwoPhaseApproach twoPhaseApproach_ = EclTwoPhaseApproach::GasOil;
395
396 std::vector<MaterialLawParams> materialLawParams_;
397 DirectionalMaterialLawParamsPtr dirMaterialLawParams_;
398
399 std::vector<int> satnumRegionArray_;
400 std::vector<int> krnumXArray_;
401 std::vector<int> krnumYArray_;
402 std::vector<int> krnumZArray_;
403 std::vector<int> imbnumXArray_;
404 std::vector<int> imbnumYArray_;
405 std::vector<int> imbnumZArray_;
406 std::vector<int> imbnumRegionArray_;
407 std::vector<Scalar> stoneEtas_;
408
409 bool hasGas;
410 bool hasOil;
411 bool hasWater;
412
413 std::shared_ptr<EclEpsConfig> gasOilConfig_;
414 std::shared_ptr<EclEpsConfig> oilWaterConfig_;
415 std::shared_ptr<EclEpsConfig> gasWaterConfig_;
416};
417} // namespace Opm
418
419#endif
This file contains definitions related to directional material law parameters.
This file contains helper classes for the material laws.
Collects all grid properties which are relevant for end point scaling.
Definition: EclEpsGridProperties.hpp:47
Represents the points on the X and Y axis to be scaled if endpoint scaling is used.
Definition: EclEpsScalingPoints.hpp:166
This material law takes a material law defined for unscaled saturation and converts it to a material ...
Definition: EclEpsTwoPhaseLaw.hpp:51
This material law implements the hysteresis model of the ECL file format.
Definition: EclHysteresisTwoPhaseLaw.hpp:44
Provides an simple way to create and manage the material law objects for a complete ECL deck.
Definition: EclMaterialLawManager.hpp:72
const MaterialLawParams & connectionMaterialLawParams(unsigned satRegionIdx, unsigned elemIdx) const
Returns a material parameter object for a given element and saturation region.
Scalar applySwatinit(unsigned elemIdx, Scalar pcow, Scalar Sw)
Modify the initial condition according to the SWATINIT keyword.
Implements a multiplexer class that provides all three phase capillary pressure laws used by the ECLi...
Definition: EclMultiplexerMaterial.hpp:58
static void updateHysteresis(Params &params, const FluidState &fluidState)
Update the hysteresis parameters after a time step.
Definition: EclMultiplexerMaterial.hpp:547
Definition: EclipseState.hpp:55
Implements a multiplexer class that provides LET curves and piecewise linear saturation functions.
Definition: SatCurveMultiplexer.hpp:44
Definition: SgfnTable.hpp:28
Definition: SgofTable.hpp:27
Definition: SlgofTable.hpp:28
Definition: TableColumn.hpp:32
A generic traits class for two-phase material laws.
Definition: MaterialTraits.hpp:61
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition: Exceptions.hpp:30
EclTwoPhaseSystemType
Specified which fluids are involved in a given twophase material law for endpoint scaling.
Definition: EclEpsConfig.hpp:42