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
194
196 static constexpr std::size_t size = 2;
197
198 // hardcoded to 2 components
199 double co2_in_water;
200 double h2o_in_water;
201
202 bool operator==(const DiffCoeffWatRecord& data) const {
203 return co2_in_water == data.co2_in_water &&
204 h2o_in_water == data.h2o_in_water;}
205
206 template<class Serializer>
207 void serializeOp(Serializer& serializer)
208 {
209 serializer(co2_in_water);
210 serializer(h2o_in_water);
211 }
212};
213
214struct DiffCoeffWatTable : public FlatTable< DiffCoeffWatRecord > {
215 using FlatTable< DiffCoeffWatRecord >::FlatTable;
216
217 static DiffCoeffWatTable serializationTestObject()
218 {
219 return DiffCoeffWatTable({{1.0, 2.0}});
220 }
221};
222
224 static constexpr std::size_t size = 2;
225
226 // hardcoded to 2 components
227 double co2_in_gas;
228 double h2o_in_gas;
229
230 bool operator==(const DiffCoeffGasRecord& data) const {
231 return co2_in_gas == data.co2_in_gas &&
232 h2o_in_gas == data.h2o_in_gas;}
233
234 template<class Serializer>
235 void serializeOp(Serializer& serializer)
236 {
237 serializer(co2_in_gas);
238 serializer(h2o_in_gas);
239 }
240};
241
242struct DiffCoeffGasTable : public FlatTable< DiffCoeffGasRecord > {
243 using FlatTable< DiffCoeffGasRecord >::FlatTable;
244
245 static DiffCoeffGasTable serializationTestObject()
246 {
247 return DiffCoeffGasTable({{1.0, 2.0}});
248 }
249};
250
252 static constexpr std::size_t size = 5;
253
254 double reference_pressure;
255 double volume_factor;
256 double compressibility;
257 double viscosity;
258 double viscosibility;
259
260 bool operator==(const PVTWRecord& data) const {
261 return reference_pressure == data.reference_pressure &&
262 volume_factor == data.volume_factor &&
263 compressibility == data.compressibility &&
264 viscosity == data.viscosity &&
265 viscosibility == data.viscosibility;
266 }
267
268 template<class Serializer>
269 void serializeOp(Serializer& serializer)
270 {
271 serializer(reference_pressure);
272 serializer(volume_factor);
273 serializer(compressibility);
274 serializer(viscosity);
275 serializer(viscosibility);
276 }
277};
278
279struct PvtwTable : public FlatTableWithCopy<PVTWRecord>
280{
281 PvtwTable() = default;
282 explicit PvtwTable(const DeckKeyword& kw);
283 explicit PvtwTable(std::initializer_list<PVTWRecord> records);
284
285 static PvtwTable serializationTestObject()
286 {
287 return PvtwTable({{1.0, 2.0, 3.0, 4.0, 5.0}});
288 }
289
290 template <class Serializer>
291 void serializeOp(Serializer& serializer)
292 {
293 FlatTableWithCopy::serializeOp(serializer);
294 }
295};
296
298 static constexpr std::size_t size = 2;
299
300 double reference_pressure;
301 double compressibility;
302
303 bool operator==(const ROCKRecord& data) const {
304 return reference_pressure == data.reference_pressure &&
305 compressibility == data.compressibility;
306 }
307
308 template<class Serializer>
309 void serializeOp(Serializer& serializer)
310 {
311 serializer(reference_pressure);
312 serializer(compressibility);
313 }
314};
315
316struct RockTable : public FlatTable< ROCKRecord > {
317 using FlatTable< ROCKRecord >::FlatTable;
318
319 static RockTable serializationTestObject()
320 {
321 return RockTable({{1.0, 2.0}});
322 }
323};
324
326 static constexpr std::size_t size = 5;
327
328 double reference_pressure;
329 double volume_factor;
330 double compressibility;
331 double viscosity;
332 double viscosibility;
333
334 bool operator==(const PVCDORecord& data) const {
335 return reference_pressure == data.reference_pressure &&
336 volume_factor == data.volume_factor &&
337 compressibility == data.compressibility &&
338 viscosity == data.viscosity &&
339 viscosibility == data.viscosibility;
340 }
341
342 template<class Serializer>
343 void serializeOp(Serializer& serializer)
344 {
345 serializer(reference_pressure);
346 serializer(volume_factor);
347 serializer(compressibility);
348 serializer(viscosity);
349 serializer(viscosibility);
350 }
351};
352
353struct PvcdoTable : public FlatTable< PVCDORecord > {
354 using FlatTable< PVCDORecord >::FlatTable;
355
356 static PvcdoTable serializationTestObject()
357 {
358 return PvcdoTable({{1.0, 2.0, 3.0, 4.0, 5.0}});
359 }
360};
361
363 static constexpr std::size_t size = 1;
364
365 double todd_langstaff;
366
367 bool operator==(const PlmixparRecord& data) const {
368 return todd_langstaff == data.todd_langstaff;
369 }
370
371 template<class Serializer>
372 void serializeOp(Serializer& serializer)
373 {
374 serializer(todd_langstaff);
375 }
376};
377
378struct PlmixparTable : public FlatTable< PlmixparRecord> {
379 using FlatTable< PlmixparRecord >::FlatTable;
380
381 static PlmixparTable serializationTestObject()
382 {
383 return PlmixparTable({PlmixparRecord{1.0}});
384 }
385};
386
388 static constexpr std::size_t size = 4;
389
390 double k_mh;
391 double a_mh;
392 double gamma;
393 double kappa;
394
395 bool operator==(const PlyvmhRecord& data) const {
396 return k_mh == data.k_mh &&
397 a_mh == data.a_mh &&
398 gamma == data.gamma &&
399 kappa == data.kappa;
400 }
401
402 template<class Serializer>
403 void serializeOp(Serializer& serializer)
404 {
405 serializer(k_mh);
406 serializer(a_mh);
407 serializer(gamma);
408 serializer(kappa);
409 }
410};
411
412struct PlyvmhTable : public FlatTable<PlyvmhRecord> {
413 using FlatTable< PlyvmhRecord >::FlatTable;
414
415 static PlyvmhTable serializationTestObject()
416 {
417 return PlyvmhTable({{1.0, 2.0, 3.0, 4.0}});
418 }
419};
420
422 static constexpr std::size_t size = 1;
423
424 double rate;
425
426 bool operator==(const ShrateRecord& data) const {
427 return rate == data.rate;
428 }
429
430 template<class Serializer>
431 void serializeOp(Serializer& serializer)
432 {
433 serializer(rate);
434 }
435};
436
437struct ShrateTable : public FlatTable<ShrateRecord> {
438 using FlatTable< ShrateRecord >::FlatTable;
439
440 static ShrateTable serializationTestObject()
441 {
442 return ShrateTable({ShrateRecord{1.0}});
443 }
444};
445
447 static constexpr std::size_t size = 1;
448
449 double eta;
450
451 bool operator==(const Stone1exRecord& data) const {
452 return eta == data.eta;
453 }
454
455 template<class Serializer>
456 void serializeOp(Serializer& serializer)
457 {
458 serializer(eta);
459 }
460};
461
462struct Stone1exTable : public FlatTable<Stone1exRecord> {
463 using FlatTable< Stone1exRecord >::FlatTable;
464
465 static Stone1exTable serializationTestObject()
466 {
467 return Stone1exTable({Stone1exRecord{1.0}});
468 }
469};
470
472 static constexpr std::size_t size = 2;
473
474 double viscosity;
475 double density;
476
477 bool operator==(const TlmixparRecord& data) const {
478 return viscosity == data.viscosity &&
479 density == data.density;
480 }
481
482 template<class Serializer>
483 void serializeOp(Serializer& serializer)
484 {
485 serializer(viscosity);
486 serializer(density);
487 }
488};
489
490struct TlmixparTable : public FlatTable< TlmixparRecord> {
491 using FlatTable< TlmixparRecord >::FlatTable;
492
493 static TlmixparTable serializationTestObject()
494 {
495 return TlmixparTable({{1.0, 2.0}});
496 }
497};
498
500 static constexpr std::size_t size = 2;
501
502 double reference_pressure;
503 double reference_rs;
504
505 bool operator==(const VISCREFRecord& data) const {
506 return reference_pressure == data.reference_pressure &&
507 reference_rs == data.reference_rs;
508 }
509
510 template<class Serializer>
511 void serializeOp(Serializer& serializer)
512 {
513 serializer(reference_pressure);
514 serializer(reference_rs);
515 }
516};
517
518struct ViscrefTable : public FlatTable< VISCREFRecord > {
519 using FlatTable< VISCREFRecord >::FlatTable;
520
521 static ViscrefTable serializationTestObject()
522 {
523 return ViscrefTable({{1.0, 2.0}});
524 }
525};
526
528 static constexpr std::size_t size = 3;
529
530 double reference_temperature;
531 double first_coefficient;
532 double second_coefficient;
533
534 bool operator==(const WATDENTRecord& data) const {
535 return reference_temperature == data.reference_temperature &&
536 first_coefficient == data.first_coefficient &&
537 second_coefficient == data.second_coefficient;
538 }
539
540 template<class Serializer>
541 void serializeOp(Serializer& serializer)
542 {
543 serializer(reference_temperature);
544 serializer(first_coefficient);
545 serializer(second_coefficient);
546 }
547};
548
549struct WatdentTable : public FlatTable< WATDENTRecord > {
550 using FlatTable< WATDENTRecord >::FlatTable;
551
552 static WatdentTable serializationTestObject()
553 {
554 return WatdentTable({{1.0, 2.0, 3.0}});
555 }
556};
557
559 static constexpr std::size_t size = 17;
560
561 double s1_residual;
562 double s1_critical;
563 double l1_relperm;
564 double e1_relperm;
565 double t1_relperm;
566 double krt1_relperm;
567 double s2_residual;
568 double s2_critical;
569 double l2_relperm;
570 double e2_relperm;
571 double t2_relperm;
572 double krt2_relperm;
573 double l_pc;
574 double e_pc;
575 double t_pc;
576 double pcir_pc;
577 double pct_pc;
578
579 bool operator==(const SatFuncLETRecord& data) const {
580 return s1_residual == data.s1_residual &&
581 s1_critical == data.s1_critical &&
582 l1_relperm == data.l1_relperm &&
583 e1_relperm == data.e1_relperm &&
584 t1_relperm == data.t1_relperm &&
585 krt1_relperm == data.krt1_relperm &&
586 s2_residual == data.s2_residual &&
587 s2_critical == data.s2_critical &&
588 l2_relperm == data.l2_relperm &&
589 e2_relperm == data.e2_relperm &&
590 t2_relperm == data.t2_relperm &&
591 krt2_relperm == data.krt2_relperm &&
592 l_pc == data.l_pc &&
593 e_pc == data.e_pc &&
594 t_pc == data.t_pc &&
595 pcir_pc == data.pcir_pc &&
596 pct_pc == data.pct_pc;
597 }
598
599 template<class Serializer>
600 void serializeOp(Serializer& serializer)
601 {
602 serializer(s1_residual);
603 serializer(s1_critical);
604 serializer(l1_relperm);
605 serializer(e1_relperm);
606 serializer(t1_relperm);
607 serializer(krt1_relperm);
608 serializer(s2_residual);
609 serializer(s2_critical);
610 serializer(l2_relperm);
611 serializer(e2_relperm);
612 serializer(t2_relperm);
613 serializer(krt2_relperm);
614 serializer(l_pc);
615 serializer(e_pc);
616 serializer(t_pc);
617 serializer(pcir_pc);
618 serializer(pct_pc);
619 }
620};
621
622struct SwofletTable : public FlatTable< SatFuncLETRecord > {
623 using FlatTable< SatFuncLETRecord >::FlatTable;
624
625 static SwofletTable serializationTestObject()
626 {
627 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}});
628 }
629};
630
631
632struct SgofletTable : public FlatTable< SatFuncLETRecord > {
633 using FlatTable< SatFuncLETRecord >::FlatTable;
634
635 static SgofletTable serializationTestObject()
636 {
637 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}});
638 }
639};
640
641}
642
643#endif //OPM_FLAT_TABLE_HPP
Definition: DeckKeyword.hpp:36
Definition: FlatTable.hpp:30
Class for (de-)serializing.
Definition: Serializer.hpp:84
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition: Exceptions.hpp:30
Definition: FlatTable.hpp:107
Definition: FlatTable.hpp:130
Definition: FlatTable.hpp:223
Definition: FlatTable.hpp:242
Definition: FlatTable.hpp:148
Definition: FlatTable.hpp:185
Definition: FlatTable.hpp:195
Definition: FlatTable.hpp:214
Definition: FlatTable.hpp:14
Definition: FlatTable.hpp:67
Definition: FlatTable.hpp:90
Definition: FlatTable.hpp:325
Definition: FlatTable.hpp:251
Definition: FlatTable.hpp:362
Definition: FlatTable.hpp:378
Definition: FlatTable.hpp:387
Definition: FlatTable.hpp:412
Definition: FlatTable.hpp:353
Definition: FlatTable.hpp:280
Definition: FlatTable.hpp:297
Definition: FlatTable.hpp:316
Definition: FlatTable.hpp:558
Definition: FlatTable.hpp:632
Definition: FlatTable.hpp:421
Definition: FlatTable.hpp:437
Definition: FlatTable.hpp:446
Definition: FlatTable.hpp:462
Definition: FlatTable.hpp:622
Definition: FlatTable.hpp:471
Definition: FlatTable.hpp:490
Definition: FlatTable.hpp:499
Definition: FlatTable.hpp:518
Definition: FlatTable.hpp:527
Definition: FlatTable.hpp:549