My Project
FlatTable.hpp
1 #ifndef OPM_FLAT_TABLE_HPP
2 #define OPM_FLAT_TABLE_HPP
3 
4 namespace Opm {
5 
6 class DeckKeyword;
7 
8 template< typename T >
9 struct FlatTable : public std::vector< T > {
10  FlatTable() = default;
11  explicit FlatTable( const DeckKeyword& );
12  explicit FlatTable(const std::vector<T>& data) :
13  std::vector<T>(data)
14  {}
15 
16  template<class Serializer>
17  void serializeOp(Serializer& serializer)
18  {
19  serializer.vector(*this);
20  }
21 };
22 
23 struct DENSITYRecord {
24  static constexpr std::size_t size = 3;
25 
26  double oil;
27  double water;
28  double gas;
29 
30  bool operator==(const DENSITYRecord& data) const {
31  return oil == data.oil &&
32  water == data.water &&
33  gas == data.gas;
34  }
35 
36  template<class Serializer>
37  void serializeOp(Serializer& serializer)
38  {
39  serializer(oil);
40  serializer(water);
41  serializer(gas);
42  }
43 };
44 
45 struct DensityTable : public FlatTable< DENSITYRecord > {
47 
48  static DensityTable serializeObject()
49  {
50  return DensityTable({{1.0, 2.0, 3.0}});
51  }
52 };
53 
55  static constexpr std::size_t size = 8;
56 
57  double oil_mw;
58  double gas_mw;
59  double gas_in_gas;
60  double oil_in_gas;
61  double gas_in_oil;
62  double oil_in_oil;
63  double gas_in_oil_cross_phase;
64  double oil_in_oil_cross_phase;
65 
66  bool operator==(const DiffCoeffRecord& data) const {
67  return oil_mw == data.oil_mw &&
68  gas_mw == data.gas_mw &&
69  gas_in_gas == data.gas_in_gas &&
70  oil_in_gas == data.oil_in_gas &&
71  gas_in_oil == data.gas_in_oil &&
72  oil_in_oil == data.oil_in_oil &&
73  gas_in_oil_cross_phase == data.gas_in_oil_cross_phase &&
74  oil_in_oil_cross_phase == data.oil_in_oil_cross_phase;
75  }
76 
77  template<class Serializer>
78  void serializeOp(Serializer& serializer)
79  {
80  serializer(oil_mw);
81  serializer(gas_mw);
82  serializer(gas_in_gas);
83  serializer(oil_in_gas);
84  serializer(gas_in_oil);
85  serializer(oil_in_oil);
86  serializer(gas_in_oil_cross_phase);
87  serializer(oil_in_oil_cross_phase);
88  }
89 };
90 
91 struct DiffCoeffTable : public FlatTable< DiffCoeffRecord > {
93 
94  static DiffCoeffTable serializeObject()
95  {
96  return DiffCoeffTable({{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0}});
97  }
98 };
99 
100 struct PVTWRecord {
101  static constexpr std::size_t size = 5;
102 
103  double reference_pressure;
104  double volume_factor;
105  double compressibility;
106  double viscosity;
107  double viscosibility;
108 
109  bool operator==(const PVTWRecord& data) const {
110  return reference_pressure == data.reference_pressure &&
111  volume_factor == data.volume_factor &&
112  compressibility == data.compressibility &&
113  viscosity == data.viscosity &&
114  viscosibility == data.viscosibility;
115  }
116 
117  template<class Serializer>
118  void serializeOp(Serializer& serializer)
119  {
120  serializer(reference_pressure);
121  serializer(volume_factor);
122  serializer(compressibility);
123  serializer(viscosity);
124  serializer(viscosibility);
125  }
126 };
127 
128 struct PvtwTable : public FlatTable< PVTWRecord > {
130 
131  static PvtwTable serializeObject()
132  {
133  return PvtwTable({{1.0, 2.0, 3.0, 4.0, 5.0}});
134  }
135 };
136 
137 struct ROCKRecord {
138  static constexpr std::size_t size = 2;
139 
140  double reference_pressure;
141  double compressibility;
142 
143  bool operator==(const ROCKRecord& data) const {
144  return reference_pressure == data.reference_pressure &&
145  compressibility == data.compressibility;
146  }
147 
148  template<class Serializer>
149  void serializeOp(Serializer& serializer)
150  {
151  serializer(reference_pressure);
152  serializer(compressibility);
153  }
154 };
155 
156 struct RockTable : public FlatTable< ROCKRecord > {
158 
159  static RockTable serializeObject()
160  {
161  return RockTable({{1.0, 2.0}});
162  }
163 };
164 
165 struct PVCDORecord {
166  static constexpr std::size_t size = 5;
167 
168  double reference_pressure;
169  double volume_factor;
170  double compressibility;
171  double viscosity;
172  double viscosibility;
173 
174  bool operator==(const PVCDORecord& data) const {
175  return reference_pressure == data.reference_pressure &&
176  volume_factor == data.volume_factor &&
177  compressibility == data.compressibility &&
178  viscosity == data.viscosity &&
179  viscosibility == data.viscosibility;
180  }
181 
182  template<class Serializer>
183  void serializeOp(Serializer& serializer)
184  {
185  serializer(reference_pressure);
186  serializer(volume_factor);
187  serializer(compressibility);
188  serializer(viscosity);
189  serializer(viscosibility);
190  }
191 };
192 
193 struct PvcdoTable : public FlatTable< PVCDORecord > {
195 
196  static PvcdoTable serializeObject()
197  {
198  return PvcdoTable({{1.0, 2.0, 3.0, 4.0, 5.0}});
199  }
200 };
201 
203  static constexpr std::size_t size = 1;
204 
205  double todd_langstaff;
206 
207  bool operator==(const PlmixparRecord& data) const {
208  return todd_langstaff == data.todd_langstaff;
209  }
210 
211  template<class Serializer>
212  void serializeOp(Serializer& serializer)
213  {
214  serializer(todd_langstaff);
215  }
216 };
217 
218 struct PlmixparTable : public FlatTable< PlmixparRecord> {
220 
221  static PlmixparTable serializeObject()
222  {
223  return PlmixparTable({PlmixparRecord{1.0}});
224  }
225 };
226 
227 struct PlyvmhRecord {
228  static constexpr std::size_t size = 4;
229 
230  double k_mh;
231  double a_mh;
232  double gamma;
233  double kappa;
234 
235  bool operator==(const PlyvmhRecord& data) const {
236  return k_mh == data.k_mh &&
237  a_mh == data.a_mh &&
238  gamma == data.gamma &&
239  kappa == data.kappa;
240  }
241 
242  template<class Serializer>
243  void serializeOp(Serializer& serializer)
244  {
245  serializer(k_mh);
246  serializer(a_mh);
247  serializer(gamma);
248  serializer(kappa);
249  }
250 };
251 
252 struct PlyvmhTable : public FlatTable<PlyvmhRecord> {
254 
255  static PlyvmhTable serializeObject()
256  {
257  return PlyvmhTable({{1.0, 2.0, 3.0, 4.0}});
258  }
259 };
260 
261 struct ShrateRecord {
262  static constexpr std::size_t size = 1;
263 
264  double rate;
265 
266  bool operator==(const ShrateRecord& data) const {
267  return rate == data.rate;
268  }
269 
270  template<class Serializer>
271  void serializeOp(Serializer& serializer)
272  {
273  serializer(rate);
274  }
275 };
276 
277 struct ShrateTable : public FlatTable<ShrateRecord> {
279 
280  static ShrateTable serializeObject()
281  {
282  return ShrateTable({ShrateRecord{1.0}});
283  }
284 };
285 
287  static constexpr std::size_t size = 1;
288 
289  double eta;
290 
291  bool operator==(const Stone1exRecord& data) const {
292  return eta == data.eta;
293  }
294 
295  template<class Serializer>
296  void serializeOp(Serializer& serializer)
297  {
298  serializer(eta);
299  }
300 };
301 
302 struct Stone1exTable : public FlatTable<Stone1exRecord> {
304 
305  static Stone1exTable serializeObject()
306  {
307  return Stone1exTable({Stone1exRecord{1.0}});
308  }
309 };
310 
312  static constexpr std::size_t size = 2;
313 
314  double viscosity;
315  double density;
316 
317  bool operator==(const TlmixparRecord& data) const {
318  return viscosity == data.viscosity &&
319  density == data.density;
320  }
321 
322  template<class Serializer>
323  void serializeOp(Serializer& serializer)
324  {
325  serializer(viscosity);
326  serializer(density);
327  }
328 };
329 
330 struct TlmixparTable : public FlatTable< TlmixparRecord> {
332 
333  static TlmixparTable serializeObject()
334  {
335  return TlmixparTable({{1.0, 2.0}});
336  }
337 };
338 
340  static constexpr std::size_t size = 2;
341 
342  double reference_pressure;
343  double reference_rs;
344 
345  bool operator==(const VISCREFRecord& data) const {
346  return reference_pressure == data.reference_pressure &&
347  reference_rs == data.reference_rs;
348  }
349 
350  template<class Serializer>
351  void serializeOp(Serializer& serializer)
352  {
353  serializer(reference_pressure);
354  serializer(reference_rs);
355  }
356 };
357 
358 struct ViscrefTable : public FlatTable< VISCREFRecord > {
360 
361  static ViscrefTable serializeObject()
362  {
363  return ViscrefTable({{1.0, 2.0}});
364  }
365 };
366 
368  static constexpr std::size_t size = 3;
369 
370  double reference_temperature;
371  double first_coefficient;
372  double second_coefficient;
373 
374  bool operator==(const WATDENTRecord& data) const {
375  return reference_temperature == data.reference_temperature &&
376  first_coefficient == data.first_coefficient &&
377  second_coefficient == data.second_coefficient;
378  }
379 
380  template<class Serializer>
381  void serializeOp(Serializer& serializer)
382  {
383  serializer(reference_temperature);
384  serializer(first_coefficient);
385  serializer(second_coefficient);
386  }
387 };
388 
389 struct WatdentTable : public FlatTable< WATDENTRecord > {
391 
392  static WatdentTable serializeObject()
393  {
394  return WatdentTable({{1.0, 2.0, 3.0}});
395  }
396 };
397 
398 }
399 
400 #endif //OPM_FLAT_TABLE_HPP
Definition: DeckKeyword.hpp:36
Definition: Serializer.hpp:38
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition: Exceptions.hpp:29
Definition: FlatTable.hpp:23
Definition: FlatTable.hpp:45
Definition: FlatTable.hpp:54
Definition: FlatTable.hpp:91
Definition: FlatTable.hpp:9
Definition: FlatTable.hpp:165
Definition: FlatTable.hpp:100
Definition: FlatTable.hpp:202
Definition: FlatTable.hpp:218
Definition: FlatTable.hpp:227
Definition: FlatTable.hpp:252
Definition: FlatTable.hpp:193
Definition: FlatTable.hpp:128
Definition: FlatTable.hpp:137
Definition: FlatTable.hpp:156
Definition: FlatTable.hpp:261
Definition: FlatTable.hpp:277
Definition: FlatTable.hpp:286
Definition: FlatTable.hpp:302
Definition: FlatTable.hpp:311
Definition: FlatTable.hpp:330
Definition: FlatTable.hpp:339
Definition: FlatTable.hpp:358
Definition: FlatTable.hpp:367
Definition: FlatTable.hpp:389