My Project
Loading...
Searching...
No Matches
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
102 static constexpr std::size_t size = 3;
103
104 double oil;
105 double water;
106 double gas;
107
108 bool operator==(const DENSITYRecord& data) const {
109 return oil == data.oil &&
110 water == data.water &&
111 gas == data.gas;
112 }
113
114 template<class Serializer>
115 void serializeOp(Serializer& serializer)
116 {
117 serializer(oil);
118 serializer(water);
119 serializer(gas);
120 }
121};
122
123struct DensityTable : public FlatTableWithCopy<DENSITYRecord>
124{
125 DensityTable() = default;
126 explicit DensityTable(const DeckKeyword& kw);
127 explicit DensityTable(const GravityTable& gravity);
128 explicit DensityTable(std::initializer_list<DENSITYRecord> records);
129
130 static DensityTable serializationTestObject()
131 {
132 return DensityTable({{1.0, 2.0, 3.0}});
133 }
134};
135
137 static constexpr std::size_t size = 8;
138
139 double oil_mw;
140 double gas_mw;
141 double gas_in_gas;
142 double oil_in_gas;
143 double gas_in_oil;
144 double oil_in_oil;
145 double gas_in_oil_cross_phase;
146 double oil_in_oil_cross_phase;
147
148 bool operator==(const DiffCoeffRecord& data) const {
149 return oil_mw == data.oil_mw &&
150 gas_mw == data.gas_mw &&
151 gas_in_gas == data.gas_in_gas &&
152 oil_in_gas == data.oil_in_gas &&
153 gas_in_oil == data.gas_in_oil &&
154 oil_in_oil == data.oil_in_oil &&
155 gas_in_oil_cross_phase == data.gas_in_oil_cross_phase &&
156 oil_in_oil_cross_phase == data.oil_in_oil_cross_phase;
157 }
158
159 template<class Serializer>
160 void serializeOp(Serializer& serializer)
161 {
162 serializer(oil_mw);
163 serializer(gas_mw);
164 serializer(gas_in_gas);
165 serializer(oil_in_gas);
166 serializer(gas_in_oil);
167 serializer(oil_in_oil);
168 serializer(gas_in_oil_cross_phase);
169 serializer(oil_in_oil_cross_phase);
170 }
171};
172
173struct DiffCoeffTable : public FlatTable< DiffCoeffRecord > {
174 using FlatTable< DiffCoeffRecord >::FlatTable;
175
176 static DiffCoeffTable serializationTestObject()
177 {
178 return DiffCoeffTable({{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0}});
179 }
180};
181
182
184 static constexpr std::size_t size = 2;
185
186 // hardcoded to 2 components
187 double co2_in_water;
188 double h2o_in_water;
189
190 bool operator==(const DiffCoeffWatRecord& data) const {
191 return co2_in_water == data.co2_in_water &&
192 h2o_in_water == data.h2o_in_water;}
193
194 template<class Serializer>
195 void serializeOp(Serializer& serializer)
196 {
197 serializer(co2_in_water);
198 serializer(h2o_in_water);
199 }
200};
201
202struct DiffCoeffWatTable : public FlatTable< DiffCoeffWatRecord > {
203 using FlatTable< DiffCoeffWatRecord >::FlatTable;
204
205 static DiffCoeffWatTable serializationTestObject()
206 {
207 return DiffCoeffWatTable({{1.0, 2.0}});
208 }
209};
210
212 static constexpr std::size_t size = 2;
213
214 // hardcoded to 2 components
215 double co2_in_gas;
216 double h2o_in_gas;
217
218 bool operator==(const DiffCoeffGasRecord& data) const {
219 return co2_in_gas == data.co2_in_gas &&
220 h2o_in_gas == data.h2o_in_gas;}
221
222 template<class Serializer>
223 void serializeOp(Serializer& serializer)
224 {
225 serializer(co2_in_gas);
226 serializer(h2o_in_gas);
227 }
228};
229
230struct DiffCoeffGasTable : public FlatTable< DiffCoeffGasRecord > {
231 using FlatTable< DiffCoeffGasRecord >::FlatTable;
232
233 static DiffCoeffGasTable serializationTestObject()
234 {
235 return DiffCoeffGasTable({{1.0, 2.0}});
236 }
237};
238
240 static constexpr std::size_t size = 5;
241
242 double reference_pressure;
243 double volume_factor;
244 double compressibility;
245 double viscosity;
246 double viscosibility;
247
248 bool operator==(const PVTWRecord& data) const {
249 return reference_pressure == data.reference_pressure &&
250 volume_factor == data.volume_factor &&
251 compressibility == data.compressibility &&
252 viscosity == data.viscosity &&
253 viscosibility == data.viscosibility;
254 }
255
256 template<class Serializer>
257 void serializeOp(Serializer& serializer)
258 {
259 serializer(reference_pressure);
260 serializer(volume_factor);
261 serializer(compressibility);
262 serializer(viscosity);
263 serializer(viscosibility);
264 }
265};
266
267struct PvtwTable : public FlatTableWithCopy<PVTWRecord>
268{
269 PvtwTable() = default;
270 explicit PvtwTable(const DeckKeyword& kw);
271 explicit PvtwTable(std::initializer_list<PVTWRecord> records);
272
273 static PvtwTable serializationTestObject()
274 {
275 return PvtwTable({{1.0, 2.0, 3.0, 4.0, 5.0}});
276 }
277};
278
280 static constexpr std::size_t size = 2;
281
282 double reference_pressure;
283 double compressibility;
284
285 bool operator==(const ROCKRecord& data) const {
286 return reference_pressure == data.reference_pressure &&
287 compressibility == data.compressibility;
288 }
289
290 template<class Serializer>
291 void serializeOp(Serializer& serializer)
292 {
293 serializer(reference_pressure);
294 serializer(compressibility);
295 }
296};
297
298struct RockTable : public FlatTableWithCopy<ROCKRecord>
299{
300 RockTable() = default;
301 explicit RockTable(const DeckKeyword& kw);
302 explicit RockTable(std::initializer_list<ROCKRecord> records);
303
304 static RockTable serializationTestObject()
305 {
306 return RockTable({{1.0, 2.0}});
307 }
308};
309
311 static constexpr std::size_t size = 5;
312
313 double reference_pressure;
314 double volume_factor;
315 double compressibility;
316 double viscosity;
317 double viscosibility;
318
319 bool operator==(const PVCDORecord& data) const {
320 return reference_pressure == data.reference_pressure &&
321 volume_factor == data.volume_factor &&
322 compressibility == data.compressibility &&
323 viscosity == data.viscosity &&
324 viscosibility == data.viscosibility;
325 }
326
327 template<class Serializer>
328 void serializeOp(Serializer& serializer)
329 {
330 serializer(reference_pressure);
331 serializer(volume_factor);
332 serializer(compressibility);
333 serializer(viscosity);
334 serializer(viscosibility);
335 }
336};
337
338struct PvcdoTable : public FlatTable< PVCDORecord > {
339 using FlatTable< PVCDORecord >::FlatTable;
340
341 static PvcdoTable serializationTestObject()
342 {
343 return PvcdoTable({{1.0, 2.0, 3.0, 4.0, 5.0}});
344 }
345};
346
348 static constexpr std::size_t size = 1;
349
350 double todd_langstaff;
351
352 bool operator==(const PlmixparRecord& data) const {
353 return todd_langstaff == data.todd_langstaff;
354 }
355
356 template<class Serializer>
357 void serializeOp(Serializer& serializer)
358 {
359 serializer(todd_langstaff);
360 }
361};
362
363struct PlmixparTable : public FlatTable< PlmixparRecord> {
364 using FlatTable< PlmixparRecord >::FlatTable;
365
366 static PlmixparTable serializationTestObject()
367 {
368 return PlmixparTable({PlmixparRecord{1.0}});
369 }
370};
371
373 static constexpr std::size_t size = 4;
374
375 double k_mh;
376 double a_mh;
377 double gamma;
378 double kappa;
379
380 bool operator==(const PlyvmhRecord& data) const {
381 return k_mh == data.k_mh &&
382 a_mh == data.a_mh &&
383 gamma == data.gamma &&
384 kappa == data.kappa;
385 }
386
387 template<class Serializer>
388 void serializeOp(Serializer& serializer)
389 {
390 serializer(k_mh);
391 serializer(a_mh);
392 serializer(gamma);
393 serializer(kappa);
394 }
395};
396
397struct PlyvmhTable : public FlatTable<PlyvmhRecord> {
398 using FlatTable< PlyvmhRecord >::FlatTable;
399
400 static PlyvmhTable serializationTestObject()
401 {
402 return PlyvmhTable({{1.0, 2.0, 3.0, 4.0}});
403 }
404};
405
407 static constexpr std::size_t size = 1;
408
409 double rate;
410
411 bool operator==(const ShrateRecord& data) const {
412 return rate == data.rate;
413 }
414
415 template<class Serializer>
416 void serializeOp(Serializer& serializer)
417 {
418 serializer(rate);
419 }
420};
421
422struct ShrateTable : public FlatTable<ShrateRecord> {
423 using FlatTable< ShrateRecord >::FlatTable;
424
425 static ShrateTable serializationTestObject()
426 {
427 return ShrateTable({ShrateRecord{1.0}});
428 }
429};
430
432 static constexpr std::size_t size = 1;
433
434 double eta;
435
436 bool operator==(const Stone1exRecord& data) const {
437 return eta == data.eta;
438 }
439
440 template<class Serializer>
441 void serializeOp(Serializer& serializer)
442 {
443 serializer(eta);
444 }
445};
446
447struct Stone1exTable : public FlatTable<Stone1exRecord> {
448 using FlatTable< Stone1exRecord >::FlatTable;
449
450 static Stone1exTable serializationTestObject()
451 {
452 return Stone1exTable({Stone1exRecord{1.0}});
453 }
454};
455
457 static constexpr std::size_t size = 2;
458
459 double viscosity;
460 double density;
461
462 bool operator==(const TlmixparRecord& data) const {
463 return viscosity == data.viscosity &&
464 density == data.density;
465 }
466
467 template<class Serializer>
468 void serializeOp(Serializer& serializer)
469 {
470 serializer(viscosity);
471 serializer(density);
472 }
473};
474
475struct TlmixparTable : public FlatTable< TlmixparRecord> {
476 using FlatTable< TlmixparRecord >::FlatTable;
477
478 static TlmixparTable serializationTestObject()
479 {
480 return TlmixparTable({{1.0, 2.0}});
481 }
482};
483
485 static constexpr std::size_t size = 2;
486
487 double reference_pressure;
488 double reference_rs;
489
490 bool operator==(const VISCREFRecord& data) const {
491 return reference_pressure == data.reference_pressure &&
492 reference_rs == data.reference_rs;
493 }
494
495 template<class Serializer>
496 void serializeOp(Serializer& serializer)
497 {
498 serializer(reference_pressure);
499 serializer(reference_rs);
500 }
501};
502
503struct ViscrefTable : public FlatTable< VISCREFRecord > {
504 using FlatTable< VISCREFRecord >::FlatTable;
505
506 static ViscrefTable serializationTestObject()
507 {
508 return ViscrefTable({{1.0, 2.0}});
509 }
510};
511
513 static constexpr std::size_t size = 3;
514
515 double reference_temperature;
516 double first_coefficient;
517 double second_coefficient;
518
519 bool operator==(const WATDENTRecord& data) const {
520 return reference_temperature == data.reference_temperature &&
521 first_coefficient == data.first_coefficient &&
522 second_coefficient == data.second_coefficient;
523 }
524
525 template<class Serializer>
526 void serializeOp(Serializer& serializer)
527 {
528 serializer(reference_temperature);
529 serializer(first_coefficient);
530 serializer(second_coefficient);
531 }
532};
533
534struct WatdentTable : public FlatTable< WATDENTRecord > {
535 using FlatTable< WATDENTRecord >::FlatTable;
536
537 static WatdentTable serializationTestObject()
538 {
539 return WatdentTable({{1.0, 2.0, 3.0}});
540 }
541};
542
544 static constexpr std::size_t size = 17;
545
546 double s1_residual;
547 double s1_critical;
548 double l1_relperm;
549 double e1_relperm;
550 double t1_relperm;
551 double krt1_relperm;
552 double s2_residual;
553 double s2_critical;
554 double l2_relperm;
555 double e2_relperm;
556 double t2_relperm;
557 double krt2_relperm;
558 double l_pc;
559 double e_pc;
560 double t_pc;
561 double pcir_pc;
562 double pct_pc;
563
564 bool operator==(const SatFuncLETRecord& data) const {
565 return s1_residual == data.s1_residual &&
566 s1_critical == data.s1_critical &&
567 l1_relperm == data.l1_relperm &&
568 e1_relperm == data.e1_relperm &&
569 t1_relperm == data.t1_relperm &&
570 krt1_relperm == data.krt1_relperm &&
571 s2_residual == data.s2_residual &&
572 s2_critical == data.s2_critical &&
573 l2_relperm == data.l2_relperm &&
574 e2_relperm == data.e2_relperm &&
575 t2_relperm == data.t2_relperm &&
576 krt2_relperm == data.krt2_relperm &&
577 l_pc == data.l_pc &&
578 e_pc == data.e_pc &&
579 t_pc == data.t_pc &&
580 pcir_pc == data.pcir_pc &&
581 pct_pc == data.pct_pc;
582 }
583
584 template<class Serializer>
585 void serializeOp(Serializer& serializer)
586 {
587 serializer(s1_residual);
588 serializer(s1_critical);
589 serializer(l1_relperm);
590 serializer(e1_relperm);
591 serializer(t1_relperm);
592 serializer(krt1_relperm);
593 serializer(s2_residual);
594 serializer(s2_critical);
595 serializer(l2_relperm);
596 serializer(e2_relperm);
597 serializer(t2_relperm);
598 serializer(krt2_relperm);
599 serializer(l_pc);
600 serializer(e_pc);
601 serializer(t_pc);
602 serializer(pcir_pc);
603 serializer(pct_pc);
604 }
605};
606
607struct SwofletTable : public FlatTable< SatFuncLETRecord > {
608 using FlatTable< SatFuncLETRecord >::FlatTable;
609
610 static SwofletTable serializationTestObject()
611 {
612 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}});
613 }
614};
615
616
617struct SgofletTable : public FlatTable< SatFuncLETRecord > {
618 using FlatTable< SatFuncLETRecord >::FlatTable;
619
620 static SgofletTable serializationTestObject()
621 {
622 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}});
623 }
624};
625
626}
627
628#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:101
Definition FlatTable.hpp:124
Definition FlatTable.hpp:211
Definition FlatTable.hpp:230
Definition FlatTable.hpp:136
Definition FlatTable.hpp:173
Definition FlatTable.hpp:183
Definition FlatTable.hpp:202
Definition FlatTable.hpp:14
Definition FlatTable.hpp:67
Definition FlatTable.hpp:90
Definition FlatTable.hpp:310
Definition FlatTable.hpp:239
Definition FlatTable.hpp:347
Definition FlatTable.hpp:363
Definition FlatTable.hpp:372
Definition FlatTable.hpp:397
Definition FlatTable.hpp:338
Definition FlatTable.hpp:268
Definition FlatTable.hpp:279
Definition FlatTable.hpp:299
Definition FlatTable.hpp:543
Definition FlatTable.hpp:617
Definition FlatTable.hpp:406
Definition FlatTable.hpp:422
Definition FlatTable.hpp:431
Definition FlatTable.hpp:447
Definition FlatTable.hpp:607
Definition FlatTable.hpp:456
Definition FlatTable.hpp:475
Definition FlatTable.hpp:484
Definition FlatTable.hpp:503
Definition FlatTable.hpp:512
Definition FlatTable.hpp:534