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 
54 struct GRAVITYRecord {
55  static constexpr std::size_t size = 3;
56 
57  double oil_api;
58  double water_sg;
59  double gas_sg;
60 
61  bool operator==(const GRAVITYRecord& data) const {
62  return this->oil_api == data.oil_api &&
63  this->water_sg == data.water_sg &&
64  this->gas_sg == data.gas_sg;
65  }
66 
67  template<class Serializer>
68  void serializeOp(Serializer& serializer)
69  {
70  serializer(this->oil_api);
71  serializer(this->water_sg);
72  serializer(this->gas_sg);
73  }
74 };
75 
76 struct GravityTable : public FlatTable< GRAVITYRecord > {
78 
79  static GravityTable serializeObject()
80  {
81  return GravityTable({{1.0, 2.0, 3.0}});
82  }
83 };
84 
86  static constexpr std::size_t size = 8;
87 
88  double oil_mw;
89  double gas_mw;
90  double gas_in_gas;
91  double oil_in_gas;
92  double gas_in_oil;
93  double oil_in_oil;
94  double gas_in_oil_cross_phase;
95  double oil_in_oil_cross_phase;
96 
97  bool operator==(const DiffCoeffRecord& data) const {
98  return oil_mw == data.oil_mw &&
99  gas_mw == data.gas_mw &&
100  gas_in_gas == data.gas_in_gas &&
101  oil_in_gas == data.oil_in_gas &&
102  gas_in_oil == data.gas_in_oil &&
103  oil_in_oil == data.oil_in_oil &&
104  gas_in_oil_cross_phase == data.gas_in_oil_cross_phase &&
105  oil_in_oil_cross_phase == data.oil_in_oil_cross_phase;
106  }
107 
108  template<class Serializer>
109  void serializeOp(Serializer& serializer)
110  {
111  serializer(oil_mw);
112  serializer(gas_mw);
113  serializer(gas_in_gas);
114  serializer(oil_in_gas);
115  serializer(gas_in_oil);
116  serializer(oil_in_oil);
117  serializer(gas_in_oil_cross_phase);
118  serializer(oil_in_oil_cross_phase);
119  }
120 };
121 
122 struct DiffCoeffTable : public FlatTable< DiffCoeffRecord > {
124 
125  static DiffCoeffTable serializeObject()
126  {
127  return DiffCoeffTable({{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0}});
128  }
129 };
130 
131 struct PVTWRecord {
132  static constexpr std::size_t size = 5;
133 
134  double reference_pressure;
135  double volume_factor;
136  double compressibility;
137  double viscosity;
138  double viscosibility;
139 
140  bool operator==(const PVTWRecord& data) const {
141  return reference_pressure == data.reference_pressure &&
142  volume_factor == data.volume_factor &&
143  compressibility == data.compressibility &&
144  viscosity == data.viscosity &&
145  viscosibility == data.viscosibility;
146  }
147 
148  template<class Serializer>
149  void serializeOp(Serializer& serializer)
150  {
151  serializer(reference_pressure);
152  serializer(volume_factor);
153  serializer(compressibility);
154  serializer(viscosity);
155  serializer(viscosibility);
156  }
157 };
158 
159 struct PvtwTable : public FlatTable< PVTWRecord > {
161 
162  static PvtwTable serializeObject()
163  {
164  return PvtwTable({{1.0, 2.0, 3.0, 4.0, 5.0}});
165  }
166 };
167 
168 struct ROCKRecord {
169  static constexpr std::size_t size = 2;
170 
171  double reference_pressure;
172  double compressibility;
173 
174  bool operator==(const ROCKRecord& data) const {
175  return reference_pressure == data.reference_pressure &&
176  compressibility == data.compressibility;
177  }
178 
179  template<class Serializer>
180  void serializeOp(Serializer& serializer)
181  {
182  serializer(reference_pressure);
183  serializer(compressibility);
184  }
185 };
186 
187 struct RockTable : public FlatTable< ROCKRecord > {
189 
190  static RockTable serializeObject()
191  {
192  return RockTable({{1.0, 2.0}});
193  }
194 };
195 
196 struct PVCDORecord {
197  static constexpr std::size_t size = 5;
198 
199  double reference_pressure;
200  double volume_factor;
201  double compressibility;
202  double viscosity;
203  double viscosibility;
204 
205  bool operator==(const PVCDORecord& data) const {
206  return reference_pressure == data.reference_pressure &&
207  volume_factor == data.volume_factor &&
208  compressibility == data.compressibility &&
209  viscosity == data.viscosity &&
210  viscosibility == data.viscosibility;
211  }
212 
213  template<class Serializer>
214  void serializeOp(Serializer& serializer)
215  {
216  serializer(reference_pressure);
217  serializer(volume_factor);
218  serializer(compressibility);
219  serializer(viscosity);
220  serializer(viscosibility);
221  }
222 };
223 
224 struct PvcdoTable : public FlatTable< PVCDORecord > {
226 
227  static PvcdoTable serializeObject()
228  {
229  return PvcdoTable({{1.0, 2.0, 3.0, 4.0, 5.0}});
230  }
231 };
232 
234  static constexpr std::size_t size = 1;
235 
236  double todd_langstaff;
237 
238  bool operator==(const PlmixparRecord& data) const {
239  return todd_langstaff == data.todd_langstaff;
240  }
241 
242  template<class Serializer>
243  void serializeOp(Serializer& serializer)
244  {
245  serializer(todd_langstaff);
246  }
247 };
248 
249 struct PlmixparTable : public FlatTable< PlmixparRecord> {
251 
252  static PlmixparTable serializeObject()
253  {
254  return PlmixparTable({PlmixparRecord{1.0}});
255  }
256 };
257 
258 struct PlyvmhRecord {
259  static constexpr std::size_t size = 4;
260 
261  double k_mh;
262  double a_mh;
263  double gamma;
264  double kappa;
265 
266  bool operator==(const PlyvmhRecord& data) const {
267  return k_mh == data.k_mh &&
268  a_mh == data.a_mh &&
269  gamma == data.gamma &&
270  kappa == data.kappa;
271  }
272 
273  template<class Serializer>
274  void serializeOp(Serializer& serializer)
275  {
276  serializer(k_mh);
277  serializer(a_mh);
278  serializer(gamma);
279  serializer(kappa);
280  }
281 };
282 
283 struct PlyvmhTable : public FlatTable<PlyvmhRecord> {
285 
286  static PlyvmhTable serializeObject()
287  {
288  return PlyvmhTable({{1.0, 2.0, 3.0, 4.0}});
289  }
290 };
291 
292 struct ShrateRecord {
293  static constexpr std::size_t size = 1;
294 
295  double rate;
296 
297  bool operator==(const ShrateRecord& data) const {
298  return rate == data.rate;
299  }
300 
301  template<class Serializer>
302  void serializeOp(Serializer& serializer)
303  {
304  serializer(rate);
305  }
306 };
307 
308 struct ShrateTable : public FlatTable<ShrateRecord> {
310 
311  static ShrateTable serializeObject()
312  {
313  return ShrateTable({ShrateRecord{1.0}});
314  }
315 };
316 
318  static constexpr std::size_t size = 1;
319 
320  double eta;
321 
322  bool operator==(const Stone1exRecord& data) const {
323  return eta == data.eta;
324  }
325 
326  template<class Serializer>
327  void serializeOp(Serializer& serializer)
328  {
329  serializer(eta);
330  }
331 };
332 
333 struct Stone1exTable : public FlatTable<Stone1exRecord> {
335 
336  static Stone1exTable serializeObject()
337  {
338  return Stone1exTable({Stone1exRecord{1.0}});
339  }
340 };
341 
343  static constexpr std::size_t size = 2;
344 
345  double viscosity;
346  double density;
347 
348  bool operator==(const TlmixparRecord& data) const {
349  return viscosity == data.viscosity &&
350  density == data.density;
351  }
352 
353  template<class Serializer>
354  void serializeOp(Serializer& serializer)
355  {
356  serializer(viscosity);
357  serializer(density);
358  }
359 };
360 
361 struct TlmixparTable : public FlatTable< TlmixparRecord> {
363 
364  static TlmixparTable serializeObject()
365  {
366  return TlmixparTable({{1.0, 2.0}});
367  }
368 };
369 
371  static constexpr std::size_t size = 2;
372 
373  double reference_pressure;
374  double reference_rs;
375 
376  bool operator==(const VISCREFRecord& data) const {
377  return reference_pressure == data.reference_pressure &&
378  reference_rs == data.reference_rs;
379  }
380 
381  template<class Serializer>
382  void serializeOp(Serializer& serializer)
383  {
384  serializer(reference_pressure);
385  serializer(reference_rs);
386  }
387 };
388 
389 struct ViscrefTable : public FlatTable< VISCREFRecord > {
391 
392  static ViscrefTable serializeObject()
393  {
394  return ViscrefTable({{1.0, 2.0}});
395  }
396 };
397 
399  static constexpr std::size_t size = 3;
400 
401  double reference_temperature;
402  double first_coefficient;
403  double second_coefficient;
404 
405  bool operator==(const WATDENTRecord& data) const {
406  return reference_temperature == data.reference_temperature &&
407  first_coefficient == data.first_coefficient &&
408  second_coefficient == data.second_coefficient;
409  }
410 
411  template<class Serializer>
412  void serializeOp(Serializer& serializer)
413  {
414  serializer(reference_temperature);
415  serializer(first_coefficient);
416  serializer(second_coefficient);
417  }
418 };
419 
420 struct WatdentTable : public FlatTable< WATDENTRecord > {
422 
423  static WatdentTable serializeObject()
424  {
425  return WatdentTable({{1.0, 2.0, 3.0}});
426  }
427 };
428 
429 }
430 
431 #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:85
Definition: FlatTable.hpp:122
Definition: FlatTable.hpp:9
Definition: FlatTable.hpp:54
Definition: FlatTable.hpp:76
Definition: FlatTable.hpp:196
Definition: FlatTable.hpp:131
Definition: FlatTable.hpp:233
Definition: FlatTable.hpp:249
Definition: FlatTable.hpp:258
Definition: FlatTable.hpp:283
Definition: FlatTable.hpp:224
Definition: FlatTable.hpp:159
Definition: FlatTable.hpp:168
Definition: FlatTable.hpp:187
Definition: FlatTable.hpp:292
Definition: FlatTable.hpp:308
Definition: FlatTable.hpp:317
Definition: FlatTable.hpp:333
Definition: FlatTable.hpp:342
Definition: FlatTable.hpp:361
Definition: FlatTable.hpp:370
Definition: FlatTable.hpp:389
Definition: FlatTable.hpp:398
Definition: FlatTable.hpp:420