My Project
Loading...
Searching...
No Matches
FieldPropsManager.hpp
1/*
2 Copyright 2019 Equinor ASA.
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 it under the terms
7 of the GNU General Public License as published by the Free Software
8 Foundation, either version 3 of the License, or (at your option) any later
9 version.
10
11 OPM is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
13 A PARTICULAR PURPOSE. See the GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License along with
16 OPM. If not, see <http://www.gnu.org/licenses/>.
17*/
18
19#ifndef FIELDPROPS_MANAGER_HPP
20#define FIELDPROPS_MANAGER_HPP
21
22#include <memory>
23#include <string>
24#include <string_view>
25#include <unordered_map>
26#include <vector>
27
28namespace Opm {
29
30class EclipseGrid;
31class Deck;
32class DeckKeyword;
33namespace Fieldprops {
34class TranCalculator;
35template<typename T> struct FieldData;
36}
37class FieldProps;
38class Phases;
39class TableManager;
40class NumericalAquifers;
41
43
44
45public:
46 // The default constructor should be removed when the FieldPropsManager is mandatory
47 // The default constructed fieldProps object is **NOT** usable
48 FieldPropsManager() = default;
49 FieldPropsManager(const Deck& deck, const Phases& ph, const EclipseGrid& grid, const TableManager& tables);
50 virtual ~FieldPropsManager() = default;
51
52 virtual void reset_actnum(const std::vector<int>& actnum);
53 void deleteMINPVV();
54 const std::string& default_region() const;
55 virtual std::vector<int> actnum() const;
56 virtual std::vector<double> porv(bool global = false) const;
57
58
59 void apply_schedule_keywords(const std::vector<DeckKeyword>& keywords);
60
62 bool is_usable() const;
63
64 /*
65 The number of cells in the fields managed by this FieldPropsManager.
66 Initially this will correspond to the number of active cells in the grid
67 used when constructing the FieldPropsManager, but using the reset_actnum()
68 method it is possible to deactivate additional cells.
69 */
70 std::size_t active_size() const;
71
72 bool operator==(const FieldPropsManager& other) const;
73 static bool rst_cmp(const FieldPropsManager& full_arg, const FieldPropsManager& rst_arg);
74
75 /*
76 Because the FieldProps class can autocreate properties the semantics of
77 get() and has() is slightly non intuitve:
78
79 - The has<T>("KW") method will check if the current FieldProps container
80 has an installed "KW" keyword; if the container has the keyword in
81 question it will check if all elements have been assigned a value - only
82 in that case will it return true. The has<T>("KW") method will *not* try
83 to create a new keyword.
84
85 - The has<T>("KW") method will *not* consult the supported<T>("KW")
86 method; i.e. if you ask has<T>("UNKNOWN_KEYWORD") you will just get a
87 false.
88
89 - The get<T>("KW") method will try to create a new keyword if it does not
90 already have the keyword you are asking for. This implies that you can
91 get the following non intuitive sequence of events:
92
93 FieldPropsManager fpm(deck, grid);
94
95 fpm.has<int>("SATNUM"); => false
96 auto satnum = fpm.get<int>("SATNUM"); => SATNUM is autocreated
97 fpm.has<int>("SATNUM"); => true
98
99 - When checking whether the container has the keyword you should rephrase
100 the question slightly:
101
102 * Does the container have the keyword *right now* => has<T>("KW")
103 * Can the container provide the keyword => ptr = try_get<T>("KW")
104
105 - It is quite simple to create a deck where the keywords are only partly
106 initialized, all the methods in the FieldPropsManager only consider
107 fully initialized keywords.
108 */
109
110
111 /*
112 The get_copy() has exactly the same behaviour as get(), but the important
113 difference is that said keyword is not already in the container it is not
114 installed in the container; if we look at SATNUM which is a keywor which
115 can be automatically instantiated we have the following behavior:
116
117 get():
118 fp.has<int>("SATNUM") -> false
119 const std::vector<int>& satnum = fp.get<int>("SATNUM")
120 fp.has<int>("SATNUM") -> true;
121
122
123 get_copy():
124 fp.has<int>("SATNUM") -> false
125 const std::vector<int>& satnum = fp.get_copy<int>("SATNUM")
126 fp.has<int>("SATNUM") -> false
127 */
128
129
130 template <typename T>
131 std::vector<T> get_copy(const std::string& keyword, bool global=false) const;
132
133 /*
134 Will return a pointer to the keyword data, or nullptr if the container
135 does not have suce a keyword. Observe that container will hold on to an
136 manage the underlying keyword data.
137
138 The try_get function will return a nullptr if the container does not
139 contain said keyword, or if the keyword has not been fully initialized. If
140 you ask for a totally unknown keyword the method will return nullptr.
141 */
142 template <typename T>
143 const std::vector<T>* try_get(const std::string& keyword) const;
144
145 /*
146 You can ask whether the elements in the keyword have a default value -
147 which typically is calculated in some way, or if it has been explicitly
148 assigned to in the deck.
149 */
150 template <typename T>
151 std::vector<bool> defaulted(const std::string& keyword) const;
152
153
154 /*
155 Check whether the container supports/recognizes a keyword at all:
156
157 supported<double>("PORO") => true
158 supported<double>("NO_SUCH_KEYWORD") => false
159
160 The method does not at all consult the content of the container - it is a
161 static method.
162 */
163 template <typename T>
164 static bool supported(const std::string& keyword);
165
166 /*
167 The keys() function will return a list of keys corresponding to the fully
168 initialized keywords in the container. Observe that the implementation
169 special cases the PORV and ACTNUM keywords, since these are present with
170 special functions porv(bool) and actnum() the "PORV" and "ACTNUM" string
171 literals are excluded from the keys() list.
172 */
173 template <typename T>
174 std::vector<std::string> keys() const;
175
176 virtual std::vector<std::string> fip_regions() const;
177
179 get_int_field_data(const std::string& keyword) const;
180
185 get_double_field_data(const std::string& keyword, bool allow_unsupported=false) const;
186 virtual const std::vector<int>& get_int(const std::string& keyword) const { return this->get<int>(keyword); }
187 virtual std::vector<int> get_global_int(const std::string& keyword) const { return this->get_global<int>(keyword); }
188
189 virtual const std::vector<double>& get_double(const std::string& keyword) const { return this->get<double>(keyword); }
190 virtual std::vector<double> get_global_double(const std::string& keyword) const { return this->get_global<double>(keyword); }
191
192 virtual bool has_int(const std::string& keyword) const { return this->has<int>(keyword); }
193 virtual bool has_double(const std::string& keyword) const { return this->has<double>(keyword); }
194
195 /*
196 The transmissibility keywords TRANX, TRANY and TRANZ do not really fit
197 well in the FieldProps system. The opm codebase is based on a full
198 internalization in the parse phase, and then passing fully assembled
199 objects to the simulator. When it comes to the transmissibilities this
200 model breaks down because the input code in opm-common is not capable of
201 calculating the transmissibility, that is performed in the simulator.
202
203 The EDIT section can have modifiers on TRAN, these must be applied *after*
204 the initial transmissibilities are calculated. To support this all the
205 modifiers to the TRAN{XYZ} fields are assembled in "transmissibility
206 calculators", and then these modifiers can be applied to a TRAN vector
207 after it has been calculated in the simulator. Usage from the simulator
208 could look like:
209
210
211 const auto& fp = eclState.fieldProps();
212
213 // Calculate transmissibilities using grid and permeability
214 std::vector<double> tranx = ....
215
216 // Check if there are any active TRANX modifiers and apply them
217 if (fp.tran_active("TRANX"))
218 fp.apply_tran("TRANX", tranx);
219
220
221 */
222
223 /*
224 Will check if there are any TRAN{XYZ} modifiers active in the deck.
225 */
226 virtual bool tran_active(const std::string& keyword) const;
227
228
229 /*
230 Will apply all the TRAN modifiers which are present in the deck on the
231 already initialized vector tran_data. The vector tran_data should be
232 organised as the data vectors in the fieldpropsmanager - i.e. one element
233 for each active cell - in lexicographical order. The operations which are
234 supported by the transmissibility calculator are those given by the enum
235 ScalarOperation in FieldProps.hpp.
236 */
237 virtual void apply_tran(const std::string& keyword, std::vector<double>& tran_data) const;
238
239 void apply_numerical_aquifers(const NumericalAquifers& aquifers);
240
241 const std::unordered_map<std::string,Fieldprops::TranCalculator>& getTran() const;
242
243private:
244 /*
245 Return the keyword values as a std::vector<>. All elements in the return
246 value are guaranteed to be assigned a valid value. If the keyword is not
247 in the container, or not all elements have a valid value - an exception
248 will be raised:
249
250 - keyword which is not supported at all -> std::logic_error
251 - keyword which is not in the deck at all -> std::out_of_range
252 - keyword which has not been fully initialized -> std::runtime_error
253
254 Many of the keywords in the container can be automatically created, in
255 that case the get() method will silently create a new keyword and default
256 initialize if it is not already in the container. The different exceptions
257 raised for the different error conditions are the same for get(),
258 get_copy() and get_global().
259 */
260 template <typename T>
261 const std::vector<T>& get(const std::string& keyword) const;
262
263 /*
264 Will check if the container has the keyword loaded; in a fully initialized
265 state. If you ask for a keyword which is not supported at all you will
266 just get false back.
267 */
268 template <typename T>
269 bool has(const std::string& keyword) const;
270
271 /*
272 This is exactly like the get() method, but the returned vector will have
273 global cartesian size. If the field has a default value that value will be
274 used for filling in in the inactive cells, otherwise zero is used.
275 */
276 template <typename T>
277 std::vector<T> get_global(const std::string& keyword) const;
278
279 std::shared_ptr<FieldProps> fp;
280};
281
282template<class MapType>
283void apply_tran(const std::unordered_map<std::string, Fieldprops::TranCalculator>& tran,
284 const MapType& double_data,
285 std::size_t active_size,
286 const std::string& keyword, std::vector<double>& data);
287
288}
289
290#endif
Definition Deck.hpp:49
About cell information and dimension: The actual grid information is held in a pointer to an ERT ecl_...
Definition EclipseGrid.hpp:55
Definition FieldPropsManager.hpp:42
const Fieldprops::FieldData< double > & get_double_field_data(const std::string &keyword, bool allow_unsupported=false) const
Get double field data associated with a keyword.
Definition FieldPropsManager.cpp:85
bool is_usable() const
Whether we can call methods on the manager.
Definition FieldPropsManager.cpp:50
Definition NumericalAquifers.hpp:38
Definition Runspec.hpp:46
Definition TableManager.hpp:66
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30
Definition FieldData.hpp:55