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 
9 namespace Opm {
10 
11 class DeckKeyword;
12 
13 template< typename T >
14 struct 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 
28 template <typename RecordType>
30 {
31 public:
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 
63 protected:
64  std::vector<RecordType> table_{};
65 };
66 
67 struct GRAVITYRecord {
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 
89 struct 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 
129 struct 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 
185 struct DiffCoeffTable : public FlatTable< DiffCoeffRecord > {
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 struct PVTWRecord {
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 
222 struct 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 
240 struct ROCKRecord {
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 
259 struct RockTable : public FlatTable< ROCKRecord > {
261 
262  static RockTable serializationTestObject()
263  {
264  return RockTable({{1.0, 2.0}});
265  }
266 };
267 
268 struct PVCDORecord {
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 
296 struct PvcdoTable : public FlatTable< PVCDORecord > {
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 
321 struct PlmixparTable : public FlatTable< PlmixparRecord> {
323 
324  static PlmixparTable serializationTestObject()
325  {
326  return PlmixparTable({PlmixparRecord{1.0}});
327  }
328 };
329 
330 struct PlyvmhRecord {
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 
355 struct PlyvmhTable : public FlatTable<PlyvmhRecord> {
357 
358  static PlyvmhTable serializationTestObject()
359  {
360  return PlyvmhTable({{1.0, 2.0, 3.0, 4.0}});
361  }
362 };
363 
364 struct ShrateRecord {
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 
380 struct ShrateTable : public FlatTable<ShrateRecord> {
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 
405 struct Stone1exTable : public FlatTable<Stone1exRecord> {
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 
433 struct TlmixparTable : public FlatTable< TlmixparRecord> {
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 
461 struct ViscrefTable : public FlatTable< VISCREFRecord > {
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 
492 struct WatdentTable : public FlatTable< WATDENTRecord > {
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 
565 struct SwofletTable : public FlatTable< SatFuncLETRecord > {
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 
575 struct SgofletTable : public FlatTable< SatFuncLETRecord > {
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