My Project
FlatTable.hpp
1#ifndef OPM_FLAT_TABLE_HPP
2#define OPM_FLAT_TABLE_HPP
3
4#include <cstddef>
5#include <initializer_list>
6#include <string_view>
7#include <vector>
8
9namespace Opm {
10
11class DeckKeyword;
12
13template< typename T >
14struct FlatTable : public std::vector< T > {
15 FlatTable() = default;
16 explicit FlatTable( const DeckKeyword& );
17 explicit FlatTable(const std::vector<T>& data) :
18 std::vector<T>(data)
19 {}
20
21 template<class Serializer>
22 void serializeOp(Serializer& serializer)
23 {
24 serializer(static_cast<std::vector<T>&>(*this));
25 }
26};
27
28template <typename RecordType>
30{
31public:
32 FlatTableWithCopy() = default;
33 explicit FlatTableWithCopy(const DeckKeyword& kw,
34 std::string_view expect = "");
35 explicit FlatTableWithCopy(std::initializer_list<RecordType> records);
36
37 auto size() const { return this->table_.size(); }
38 bool empty() const { return this->table_.empty(); }
39 auto begin() const { return this->table_.begin(); }
40 auto end() const { return this->table_.end(); }
41
42 const RecordType& operator[](const std::size_t tableID) const
43 {
44 return this->table_[tableID];
45 }
46
47 const RecordType& at(const std::size_t tableID) const
48 {
49 return this->table_.at(tableID);
50 }
51
52 bool operator==(const FlatTableWithCopy& other) const
53 {
54 return this->table_ == other.table_;
55 }
56
57 template <class Serializer>
58 void serializeOp(Serializer& serializer)
59 {
60 serializer(this->table_);
61 }
62
63protected:
64 std::vector<RecordType> table_{};
65};
66
68 static constexpr std::size_t size = 3;
69
70 double oil_api;
71 double water_sg;
72 double gas_sg;
73
74 bool operator==(const GRAVITYRecord& data) const {
75 return this->oil_api == data.oil_api &&
76 this->water_sg == data.water_sg &&
77 this->gas_sg == data.gas_sg;
78 }
79
80 template<class Serializer>
81 void serializeOp(Serializer& serializer)
82 {
83 serializer(this->oil_api);
84 serializer(this->water_sg);
85 serializer(this->gas_sg);
86 }
87};
88
89struct GravityTable : public FlatTableWithCopy<GRAVITYRecord>
90{
91 GravityTable() = default;
92 explicit GravityTable(const DeckKeyword& kw);
93 explicit GravityTable(std::initializer_list<GRAVITYRecord> records);
94
95 static GravityTable serializationTestObject()
96 {
97 return GravityTable({{1.0, 2.0, 3.0}});
98 }
99
100 template <class Serializer>
101 void serializeOp(Serializer& serializer)
102 {
103 FlatTableWithCopy::serializeOp(serializer);
104 }
105};
106
108 static constexpr std::size_t size = 3;
109
110 double oil;
111 double water;
112 double gas;
113
114 bool operator==(const DENSITYRecord& data) const {
115 return oil == data.oil &&
116 water == data.water &&
117 gas == data.gas;
118 }
119
120 template<class Serializer>
121 void serializeOp(Serializer& serializer)
122 {
123 serializer(oil);
124 serializer(water);
125 serializer(gas);
126 }
127};
128
129struct DensityTable : public FlatTableWithCopy<DENSITYRecord>
130{
131 DensityTable() = default;
132 explicit DensityTable(const DeckKeyword& kw);
133 explicit DensityTable(const GravityTable& gravity);
134 explicit DensityTable(std::initializer_list<DENSITYRecord> records);
135
136 static DensityTable serializationTestObject()
137 {
138 return DensityTable({{1.0, 2.0, 3.0}});
139 }
140
141 template <class Serializer>
142 void serializeOp(Serializer& serializer)
143 {
144 FlatTableWithCopy::serializeOp(serializer);
145 }
146};
147
149 static constexpr std::size_t size = 8;
150
151 double oil_mw;
152 double gas_mw;
153 double gas_in_gas;
154 double oil_in_gas;
155 double gas_in_oil;
156 double oil_in_oil;
157 double gas_in_oil_cross_phase;
158 double oil_in_oil_cross_phase;
159
160 bool operator==(const DiffCoeffRecord& data) const {
161 return oil_mw == data.oil_mw &&
162 gas_mw == data.gas_mw &&
163 gas_in_gas == data.gas_in_gas &&
164 oil_in_gas == data.oil_in_gas &&
165 gas_in_oil == data.gas_in_oil &&
166 oil_in_oil == data.oil_in_oil &&
167 gas_in_oil_cross_phase == data.gas_in_oil_cross_phase &&
168 oil_in_oil_cross_phase == data.oil_in_oil_cross_phase;
169 }
170
171 template<class Serializer>
172 void serializeOp(Serializer& serializer)
173 {
174 serializer(oil_mw);
175 serializer(gas_mw);
176 serializer(gas_in_gas);
177 serializer(oil_in_gas);
178 serializer(gas_in_oil);
179 serializer(oil_in_oil);
180 serializer(gas_in_oil_cross_phase);
181 serializer(oil_in_oil_cross_phase);
182 }
183};
184
185struct DiffCoeffTable : public FlatTable< DiffCoeffRecord > {
186 using FlatTable< DiffCoeffRecord >::FlatTable;
187
188 static DiffCoeffTable serializationTestObject()
189 {
190 return DiffCoeffTable({{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0}});
191 }
192};
193
195 static constexpr std::size_t size = 5;
196
197 double reference_pressure;
198 double volume_factor;
199 double compressibility;
200 double viscosity;
201 double viscosibility;
202
203 bool operator==(const PVTWRecord& data) const {
204 return reference_pressure == data.reference_pressure &&
205 volume_factor == data.volume_factor &&
206 compressibility == data.compressibility &&
207 viscosity == data.viscosity &&
208 viscosibility == data.viscosibility;
209 }
210
211 template<class Serializer>
212 void serializeOp(Serializer& serializer)
213 {
214 serializer(reference_pressure);
215 serializer(volume_factor);
216 serializer(compressibility);
217 serializer(viscosity);
218 serializer(viscosibility);
219 }
220};
221
222struct PvtwTable : public FlatTableWithCopy<PVTWRecord>
223{
224 PvtwTable() = default;
225 explicit PvtwTable(const DeckKeyword& kw);
226 explicit PvtwTable(std::initializer_list<PVTWRecord> records);
227
228 static PvtwTable serializationTestObject()
229 {
230 return PvtwTable({{1.0, 2.0, 3.0, 4.0, 5.0}});
231 }
232
233 template <class Serializer>
234 void serializeOp(Serializer& serializer)
235 {
236 FlatTableWithCopy::serializeOp(serializer);
237 }
238};
239
241 static constexpr std::size_t size = 2;
242
243 double reference_pressure;
244 double compressibility;
245
246 bool operator==(const ROCKRecord& data) const {
247 return reference_pressure == data.reference_pressure &&
248 compressibility == data.compressibility;
249 }
250
251 template<class Serializer>
252 void serializeOp(Serializer& serializer)
253 {
254 serializer(reference_pressure);
255 serializer(compressibility);
256 }
257};
258
259struct RockTable : public FlatTable< ROCKRecord > {
260 using FlatTable< ROCKRecord >::FlatTable;
261
262 static RockTable serializationTestObject()
263 {
264 return RockTable({{1.0, 2.0}});
265 }
266};
267
269 static constexpr std::size_t size = 5;
270
271 double reference_pressure;
272 double volume_factor;
273 double compressibility;
274 double viscosity;
275 double viscosibility;
276
277 bool operator==(const PVCDORecord& data) const {
278 return reference_pressure == data.reference_pressure &&
279 volume_factor == data.volume_factor &&
280 compressibility == data.compressibility &&
281 viscosity == data.viscosity &&
282 viscosibility == data.viscosibility;
283 }
284
285 template<class Serializer>
286 void serializeOp(Serializer& serializer)
287 {
288 serializer(reference_pressure);
289 serializer(volume_factor);
290 serializer(compressibility);
291 serializer(viscosity);
292 serializer(viscosibility);
293 }
294};
295
296struct PvcdoTable : public FlatTable< PVCDORecord > {
297 using FlatTable< PVCDORecord >::FlatTable;
298
299 static PvcdoTable serializationTestObject()
300 {
301 return PvcdoTable({{1.0, 2.0, 3.0, 4.0, 5.0}});
302 }
303};
304
306 static constexpr std::size_t size = 1;
307
308 double todd_langstaff;
309
310 bool operator==(const PlmixparRecord& data) const {
311 return todd_langstaff == data.todd_langstaff;
312 }
313
314 template<class Serializer>
315 void serializeOp(Serializer& serializer)
316 {
317 serializer(todd_langstaff);
318 }
319};
320
321struct PlmixparTable : public FlatTable< PlmixparRecord> {
322 using FlatTable< PlmixparRecord >::FlatTable;
323
324 static PlmixparTable serializationTestObject()
325 {
326 return PlmixparTable({PlmixparRecord{1.0}});
327 }
328};
329
331 static constexpr std::size_t size = 4;
332
333 double k_mh;
334 double a_mh;
335 double gamma;
336 double kappa;
337
338 bool operator==(const PlyvmhRecord& data) const {
339 return k_mh == data.k_mh &&
340 a_mh == data.a_mh &&
341 gamma == data.gamma &&
342 kappa == data.kappa;
343 }
344
345 template<class Serializer>
346 void serializeOp(Serializer& serializer)
347 {
348 serializer(k_mh);
349 serializer(a_mh);
350 serializer(gamma);
351 serializer(kappa);
352 }
353};
354
355struct PlyvmhTable : public FlatTable<PlyvmhRecord> {
356 using FlatTable< PlyvmhRecord >::FlatTable;
357
358 static PlyvmhTable serializationTestObject()
359 {
360 return PlyvmhTable({{1.0, 2.0, 3.0, 4.0}});
361 }
362};
363
365 static constexpr std::size_t size = 1;
366
367 double rate;
368
369 bool operator==(const ShrateRecord& data) const {
370 return rate == data.rate;
371 }
372
373 template<class Serializer>
374 void serializeOp(Serializer& serializer)
375 {
376 serializer(rate);
377 }
378};
379
380struct ShrateTable : public FlatTable<ShrateRecord> {
381 using FlatTable< ShrateRecord >::FlatTable;
382
383 static ShrateTable serializationTestObject()
384 {
385 return ShrateTable({ShrateRecord{1.0}});
386 }
387};
388
390 static constexpr std::size_t size = 1;
391
392 double eta;
393
394 bool operator==(const Stone1exRecord& data) const {
395 return eta == data.eta;
396 }
397
398 template<class Serializer>
399 void serializeOp(Serializer& serializer)
400 {
401 serializer(eta);
402 }
403};
404
405struct Stone1exTable : public FlatTable<Stone1exRecord> {
406 using FlatTable< Stone1exRecord >::FlatTable;
407
408 static Stone1exTable serializationTestObject()
409 {
410 return Stone1exTable({Stone1exRecord{1.0}});
411 }
412};
413
415 static constexpr std::size_t size = 2;
416
417 double viscosity;
418 double density;
419
420 bool operator==(const TlmixparRecord& data) const {
421 return viscosity == data.viscosity &&
422 density == data.density;
423 }
424
425 template<class Serializer>
426 void serializeOp(Serializer& serializer)
427 {
428 serializer(viscosity);
429 serializer(density);
430 }
431};
432
433struct TlmixparTable : public FlatTable< TlmixparRecord> {
434 using FlatTable< TlmixparRecord >::FlatTable;
435
436 static TlmixparTable serializationTestObject()
437 {
438 return TlmixparTable({{1.0, 2.0}});
439 }
440};
441
443 static constexpr std::size_t size = 2;
444
445 double reference_pressure;
446 double reference_rs;
447
448 bool operator==(const VISCREFRecord& data) const {
449 return reference_pressure == data.reference_pressure &&
450 reference_rs == data.reference_rs;
451 }
452
453 template<class Serializer>
454 void serializeOp(Serializer& serializer)
455 {
456 serializer(reference_pressure);
457 serializer(reference_rs);
458 }
459};
460
461struct ViscrefTable : public FlatTable< VISCREFRecord > {
462 using FlatTable< VISCREFRecord >::FlatTable;
463
464 static ViscrefTable serializationTestObject()
465 {
466 return ViscrefTable({{1.0, 2.0}});
467 }
468};
469
471 static constexpr std::size_t size = 3;
472
473 double reference_temperature;
474 double first_coefficient;
475 double second_coefficient;
476
477 bool operator==(const WATDENTRecord& data) const {
478 return reference_temperature == data.reference_temperature &&
479 first_coefficient == data.first_coefficient &&
480 second_coefficient == data.second_coefficient;
481 }
482
483 template<class Serializer>
484 void serializeOp(Serializer& serializer)
485 {
486 serializer(reference_temperature);
487 serializer(first_coefficient);
488 serializer(second_coefficient);
489 }
490};
491
492struct WatdentTable : public FlatTable< WATDENTRecord > {
493 using FlatTable< WATDENTRecord >::FlatTable;
494
495 static WatdentTable serializationTestObject()
496 {
497 return WatdentTable({{1.0, 2.0, 3.0}});
498 }
499};
500
502 static constexpr std::size_t size = 17;
503
504 double s1_residual;
505 double s1_critical;
506 double l1_relperm;
507 double e1_relperm;
508 double t1_relperm;
509 double krt1_relperm;
510 double s2_residual;
511 double s2_critical;
512 double l2_relperm;
513 double e2_relperm;
514 double t2_relperm;
515 double krt2_relperm;
516 double l_pc;
517 double e_pc;
518 double t_pc;
519 double pcir_pc;
520 double pct_pc;
521
522 bool operator==(const SatFuncLETRecord& data) const {
523 return s1_residual == data.s1_residual &&
524 s1_critical == data.s1_critical &&
525 l1_relperm == data.l1_relperm &&
526 e1_relperm == data.e1_relperm &&
527 t1_relperm == data.t1_relperm &&
528 krt1_relperm == data.krt1_relperm &&
529 s2_residual == data.s2_residual &&
530 s2_critical == data.s2_critical &&
531 l2_relperm == data.l2_relperm &&
532 e2_relperm == data.e2_relperm &&
533 t2_relperm == data.t2_relperm &&
534 krt2_relperm == data.krt2_relperm &&
535 l_pc == data.l_pc &&
536 e_pc == data.e_pc &&
537 t_pc == data.t_pc &&
538 pcir_pc == data.pcir_pc &&
539 pct_pc == data.pct_pc;
540 }
541
542 template<class Serializer>
543 void serializeOp(Serializer& serializer)
544 {
545 serializer(s1_residual);
546 serializer(s1_critical);
547 serializer(l1_relperm);
548 serializer(e1_relperm);
549 serializer(t1_relperm);
550 serializer(krt1_relperm);
551 serializer(s2_residual);
552 serializer(s2_critical);
553 serializer(l2_relperm);
554 serializer(e2_relperm);
555 serializer(t2_relperm);
556 serializer(krt2_relperm);
557 serializer(l_pc);
558 serializer(e_pc);
559 serializer(t_pc);
560 serializer(pcir_pc);
561 serializer(pct_pc);
562 }
563};
564
565struct SwofletTable : public FlatTable< SatFuncLETRecord > {
566 using FlatTable< SatFuncLETRecord >::FlatTable;
567
568 static SwofletTable serializationTestObject()
569 {
570 return SwofletTable({{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0}});
571 }
572};
573
574
575struct SgofletTable : public FlatTable< SatFuncLETRecord > {
576 using FlatTable< SatFuncLETRecord >::FlatTable;
577
578 static SgofletTable serializationTestObject()
579 {
580 return SgofletTable({{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0}});
581 }
582};
583
584}
585
586#endif //OPM_FLAT_TABLE_HPP
Definition: DeckKeyword.hpp:36
Definition: FlatTable.hpp:30
Class for (de-)serializing.
Definition: Serializer.hpp:75
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition: Exceptions.hpp:29
Definition: FlatTable.hpp:107
Definition: FlatTable.hpp:130
Definition: FlatTable.hpp:148
Definition: FlatTable.hpp:185
Definition: FlatTable.hpp:14
Definition: FlatTable.hpp:67
Definition: FlatTable.hpp:90
Definition: FlatTable.hpp:268
Definition: FlatTable.hpp:194
Definition: FlatTable.hpp:305
Definition: FlatTable.hpp:321
Definition: FlatTable.hpp:330
Definition: FlatTable.hpp:355
Definition: FlatTable.hpp:296
Definition: FlatTable.hpp:223
Definition: FlatTable.hpp:240
Definition: FlatTable.hpp:259
Definition: FlatTable.hpp:501
Definition: FlatTable.hpp:575
Definition: FlatTable.hpp:364
Definition: FlatTable.hpp:380
Definition: FlatTable.hpp:389
Definition: FlatTable.hpp:405
Definition: FlatTable.hpp:565
Definition: FlatTable.hpp:414
Definition: FlatTable.hpp:433
Definition: FlatTable.hpp:442
Definition: FlatTable.hpp:461
Definition: FlatTable.hpp:470
Definition: FlatTable.hpp:492