20#ifndef OPM_OUTPUT_AQUIFER_HPP
21#define OPM_OUTPUT_AQUIFER_HPP
27#include <unordered_map>
32namespace Opm {
namespace data {
34 enum class AquiferType
36 Fetkovich, CarterTracy, Numerical,
43 double timeConstant{};
48 template <
class MessageBufferType>
49 void write(MessageBufferType& buffer)
const;
52 template <
class MessageBufferType>
53 void read(MessageBufferType& buffer);
55 template<
class Serializer>
58 serializer(initVolume);
59 serializer(prodIndex);
60 serializer(timeConstant);
71 double timeConstant{};
72 double influxConstant{};
73 double waterDensity{};
74 double waterViscosity{};
76 double dimensionless_time{};
77 double dimensionless_pressure{};
82 template <
class MessageBufferType>
83 void write(MessageBufferType& buffer)
const;
86 template <
class MessageBufferType>
87 void read(MessageBufferType& buffer);
89 template<
class Serializer>
92 serializer(timeConstant);
93 serializer(influxConstant);
94 serializer(waterDensity);
95 serializer(waterViscosity);
96 serializer(dimensionless_time);
97 serializer(dimensionless_pressure);
108 std::vector<double> initPressure{};
113 template <
class MessageBufferType>
114 void write(MessageBufferType& buffer)
const;
117 template <
class MessageBufferType>
118 void read(MessageBufferType& buffer);
120 template<
class Serializer>
123 serializer(initPressure);
133 template <AquiferType>
136 template <>
struct TypeMap<AquiferType::CarterTracy>
141 template <>
struct TypeMap<AquiferType::Fetkovich>
146 template <>
struct TypeMap<AquiferType::Numerical>
151 template <AquiferType t>
158 template <
typename T>
161 return std::holds_alternative<T>(this->options_);
164 template <
typename T>
167 return this->
template is<T>()
168 ? &std::get<T>(this->options_)
172 template <
typename T>
175 return this->
template is<T>()
176 ? &std::get<T>(this->options_)
191 return std::visit(Equal{}, this->options_, that.options_);
194 template <AquiferType t>
197 return &this->options_.emplace<detail::TypeMap_t<t>>();
200 template <AquiferType t>
203 return this->
template is<detail::TypeMap_t<t>>();
206 template <AquiferType t>
207 auto const* get()
const
209 return this->
template get<detail::TypeMap_t<t>>();
212 template <AquiferType t>
215 return this->
template get<detail::TypeMap_t<t>>();
218 template <
typename MessageBufferType>
219 void write(MessageBufferType& buffer)
const
221 buffer.write(this->options_.index());
222 std::visit(Write<MessageBufferType>{buffer}, this->options_);
225 template <
typename MessageBufferType>
226 void read(MessageBufferType& buffer)
228 auto type = 0 * this->options_.index();
231 if (type < std::variant_size_v<Types>) {
234 std::visit(Read<MessageBufferType>{buffer}, this->options_);
238 template<
class Serializer>
241 serializer(options_);
245 using Types = std::variant<std::monostate,
252 template <
typename T1,
typename T2>
253 bool operator()(
const T1&,
const T2&)
const
258 template <
typename T>
259 bool operator()(
const T& e1,
const T& e2)
const
264 bool operator()(
const std::monostate&,
265 const std::monostate&)
const
271 template <
typename MessageBufferType>
275 explicit Read(MessageBufferType& buffer)
279 template <
typename T>
280 void operator()(T& alternative)
282 return alternative.read(this->buffer_);
285 void operator()(std::monostate&)
289 MessageBufferType& buffer_;
292 template <
typename MessageBufferType>
296 explicit Write(MessageBufferType& buffer)
300 template <
typename T>
301 void operator()(
const T& alternative)
const
303 return alternative.write(this->buffer_);
306 void operator()(
const std::monostate&)
const
310 MessageBufferType& buffer_;
315 void create(
const std::size_t option);
321 double pressure = 0.0;
322 double fluxRate = 0.0;
324 double initPressure = 0.0;
325 double datumDepth = 0.0;
329 double get(
const std::string& key)
const;
334 template <
class MessageBufferType>
335 void write(MessageBufferType& buffer)
const;
338 template <
class MessageBufferType>
339 void read(MessageBufferType& buffer);
341 template<
class Serializer>
344 serializer(aquiferID);
345 serializer(pressure);
346 serializer(fluxRate);
348 serializer(initPressure);
349 serializer(datumDepth);
350 serializer(typeData);
355 auto aquifer =
AquiferData {1, 123.456, 56.78, 9.0e10, 290.0, 2515.5};
356 auto* aquFet = aquifer.typeData.create<AquiferType::Fetkovich>();
357 aquFet->initVolume = 1.23;
358 aquFet->prodIndex = 45.67;
359 aquFet->timeConstant = 890.123;
366 auto aquifer =
AquiferData {2, 123.456, 56.78, 9.0e10, 290.0, 2515.5};
367 auto* aquCT = aquifer.typeData.create<AquiferType::CarterTracy>();
369 aquCT->timeConstant = 987.65;
370 aquCT->influxConstant = 43.21;
371 aquCT->waterDensity = 1014.5;
372 aquCT->waterViscosity = 0.00318;
373 aquCT->dimensionless_time = 42.0;
374 aquCT->dimensionless_pressure = 2.34;
381 auto aquifer =
AquiferData {3, 123.456, 56.78, 9.0e10, 290.0, 2515.5};
382 auto* aquNum = aquifer.typeData.create<AquiferType::Numerical>();
384 aquNum->initPressure = {1.234, 2.345, 3.4, 9.876};
390 using GetSummaryValue = double (
AquiferData::*)()
const;
391 using SummaryValueDispatchTable = std::unordered_map<std::string, GetSummaryValue>;
393 static SummaryValueDispatchTable summaryValueDispatchTable_;
395 double aquiferFlowRate()
const;
396 double aquiferPressure()
const;
397 double aquiferTotalProduction()
const;
398 double carterTracyDimensionlessTime()
const;
399 double carterTracyDimensionlessPressure()
const;
403 using Aquifers = std::map<int, AquiferData>;
405 template <
class MessageBufferType>
406 void FetkovichData::write(MessageBufferType& buffer)
const
408 buffer.write(this->initVolume);
409 buffer.write(this->prodIndex);
410 buffer.write(this->timeConstant);
413 template <
class MessageBufferType>
414 void FetkovichData::read(MessageBufferType& buffer)
416 buffer.read(this->initVolume);
417 buffer.read(this->prodIndex);
418 buffer.read(this->timeConstant);
421 template <
class MessageBufferType>
422 void CarterTracyData::write(MessageBufferType& buffer)
const
424 buffer.write(this->timeConstant);
425 buffer.write(this->influxConstant);
426 buffer.write(this->waterDensity);
427 buffer.write(this->waterViscosity);
428 buffer.write(this->dimensionless_time);
429 buffer.write(this->dimensionless_pressure);
432 template <
class MessageBufferType>
433 void CarterTracyData::read(MessageBufferType& buffer)
435 buffer.read(this->timeConstant);
436 buffer.read(this->influxConstant);
437 buffer.read(this->waterDensity);
438 buffer.read(this->waterViscosity);
439 buffer.read(this->dimensionless_time);
440 buffer.read(this->dimensionless_pressure);
443 template <
class MessageBufferType>
444 void NumericAquiferData::write(MessageBufferType& buffer)
const
446 buffer.write(this->initPressure.size());
448 for (
const auto& pressure : this->initPressure) {
449 buffer.write(pressure);
453 template <
class MessageBufferType>
454 void NumericAquiferData::read(MessageBufferType& buffer)
456 decltype(this->initPressure.size()) size{};
459 this->initPressure.resize(size, 0.0);
460 for (
auto& pressure : this->initPressure) {
461 buffer.read(pressure);
465 template <
class MessageBufferType>
466 void AquiferData::write(MessageBufferType& buffer)
const
468 buffer.write(this->aquiferID);
469 buffer.write(this->pressure);
470 buffer.write(this->fluxRate);
471 buffer.write(this->volume);
472 buffer.write(this->initPressure);
473 buffer.write(this->datumDepth);
475 this->typeData.write(buffer);
478 template <
class MessageBufferType>
479 void AquiferData::read(MessageBufferType& buffer)
481 buffer.read(this->aquiferID);
482 buffer.read(this->pressure);
483 buffer.read(this->fluxRate);
484 buffer.read(this->volume);
485 buffer.read(this->initPressure);
486 buffer.read(this->datumDepth);
488 this->typeData.read(buffer);
Class for (de-)serializing.
Definition: Serializer.hpp:75
Definition: Aquifer.hpp:156
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition: Exceptions.hpp:29
Definition: Aquifer.hpp:319
Definition: Aquifer.hpp:70
Definition: Aquifer.hpp:40
Definition: Aquifer.hpp:107
Definition: Aquifer.hpp:134