20#ifndef OPM_OUTPUT_AQUIFER_HPP
21#define OPM_OUTPUT_AQUIFER_HPP
26#include <unordered_map>
30namespace Opm {
namespace data {
32 enum class AquiferType
34 Fetkovich, CarterTracy, ConstantFlux, Numerical,
41 double timeConstant{};
46 template <
class MessageBufferType>
47 void write(MessageBufferType& buffer)
const;
50 template <
class MessageBufferType>
51 void read(MessageBufferType& buffer);
53 template<
class Serializer>
56 serializer(initVolume);
57 serializer(prodIndex);
58 serializer(timeConstant);
69 double timeConstant{};
70 double influxConstant{};
71 double waterDensity{};
72 double waterViscosity{};
74 double dimensionless_time{};
75 double dimensionless_pressure{};
80 template <
class MessageBufferType>
81 void write(MessageBufferType& buffer)
const;
84 template <
class MessageBufferType>
85 void read(MessageBufferType& buffer);
87 template<
class Serializer>
90 serializer(timeConstant);
91 serializer(influxConstant);
92 serializer(waterDensity);
93 serializer(waterViscosity);
94 serializer(dimensionless_time);
95 serializer(dimensionless_pressure);
106 std::vector<double> initPressure{};
111 template <
class MessageBufferType>
112 void write(MessageBufferType& buffer)
const;
115 template <
class MessageBufferType>
116 void read(MessageBufferType& buffer);
118 template<
class Serializer>
121 serializer(initPressure);
131 template <AquiferType>
134 template <>
struct TypeMap<AquiferType::CarterTracy>
139 template <>
struct TypeMap<AquiferType::Fetkovich>
144 template <>
struct TypeMap<AquiferType::Numerical>
149 template <AquiferType t>
156 template <
typename T>
159 return std::holds_alternative<T>(this->options_);
162 template <
typename T>
165 return this->
template is<T>()
166 ? &std::get<T>(this->options_)
170 template <
typename T>
173 return this->
template is<T>()
174 ? &std::get<T>(this->options_)
189 return std::visit(Equal{}, this->options_, that.options_);
192 template <AquiferType t>
195 return &this->options_.emplace<detail::TypeMap_t<t>>();
198 template <AquiferType t>
201 return this->
template is<detail::TypeMap_t<t>>();
204 template <AquiferType t>
205 auto const* get()
const
207 return this->
template get<detail::TypeMap_t<t>>();
210 template <AquiferType t>
213 return this->
template get<detail::TypeMap_t<t>>();
216 template <
typename MessageBufferType>
217 void write(MessageBufferType& buffer)
const
219 buffer.write(this->options_.index());
220 std::visit(Write<MessageBufferType>{buffer}, this->options_);
223 template <
typename MessageBufferType>
224 void read(MessageBufferType& buffer)
226 auto type = 0 * this->options_.index();
229 if (type < std::variant_size_v<Types>) {
232 std::visit(Read<MessageBufferType>{buffer}, this->options_);
236 template<
class Serializer>
239 serializer(options_);
243 using Types = std::variant<std::monostate,
250 template <
typename T1,
typename T2>
251 bool operator()(
const T1&,
const T2&)
const
256 template <
typename T>
257 bool operator()(
const T& e1,
const T& e2)
const
262 bool operator()(
const std::monostate&,
263 const std::monostate&)
const
269 template <
typename MessageBufferType>
273 explicit Read(MessageBufferType& buffer)
277 template <
typename T>
278 void operator()(T& alternative)
280 return alternative.read(this->buffer_);
283 void operator()(std::monostate&)
287 MessageBufferType& buffer_;
290 template <
typename MessageBufferType>
294 explicit Write(MessageBufferType& buffer)
298 template <
typename T>
299 void operator()(
const T& alternative)
const
301 return alternative.write(this->buffer_);
304 void operator()(
const std::monostate&)
const
308 MessageBufferType& buffer_;
313 void create(
const std::size_t option);
319 double pressure = 0.0;
320 double fluxRate = 0.0;
322 double initPressure = 0.0;
323 double datumDepth = 0.0;
327 double get(
const std::string& key)
const;
332 template <
class MessageBufferType>
333 void write(MessageBufferType& buffer)
const;
336 template <
class MessageBufferType>
337 void read(MessageBufferType& buffer);
339 template<
class Serializer>
342 serializer(aquiferID);
343 serializer(pressure);
344 serializer(fluxRate);
346 serializer(initPressure);
347 serializer(datumDepth);
348 serializer(typeData);
353 auto aquifer =
AquiferData {1, 123.456, 56.78, 9.0e10, 290.0, 2515.5};
354 auto* aquFet = aquifer.typeData.create<AquiferType::Fetkovich>();
355 aquFet->initVolume = 1.23;
356 aquFet->prodIndex = 45.67;
357 aquFet->timeConstant = 890.123;
364 auto aquifer =
AquiferData {2, 123.456, 56.78, 9.0e10, 290.0, 2515.5};
365 auto* aquCT = aquifer.typeData.create<AquiferType::CarterTracy>();
367 aquCT->timeConstant = 987.65;
368 aquCT->influxConstant = 43.21;
369 aquCT->waterDensity = 1014.5;
370 aquCT->waterViscosity = 0.00318;
371 aquCT->dimensionless_time = 42.0;
372 aquCT->dimensionless_pressure = 2.34;
379 auto aquifer =
AquiferData {3, 123.456, 56.78, 9.0e10, 290.0, 2515.5};
380 auto* aquNum = aquifer.typeData.create<AquiferType::Numerical>();
382 aquNum->initPressure = {1.234, 2.345, 3.4, 9.876};
388 using GetSummaryValue = double (
AquiferData::*)()
const;
389 using SummaryValueDispatchTable = std::unordered_map<std::string, GetSummaryValue>;
391 static SummaryValueDispatchTable summaryValueDispatchTable_;
393 double aquiferFlowRate()
const;
394 double aquiferPressure()
const;
395 double aquiferTotalProduction()
const;
396 double carterTracyDimensionlessTime()
const;
397 double carterTracyDimensionlessPressure()
const;
401 using Aquifers = std::map<int, AquiferData>;
403 template <
class MessageBufferType>
404 void FetkovichData::write(MessageBufferType& buffer)
const
406 buffer.write(this->initVolume);
407 buffer.write(this->prodIndex);
408 buffer.write(this->timeConstant);
411 template <
class MessageBufferType>
412 void FetkovichData::read(MessageBufferType& buffer)
414 buffer.read(this->initVolume);
415 buffer.read(this->prodIndex);
416 buffer.read(this->timeConstant);
419 template <
class MessageBufferType>
420 void CarterTracyData::write(MessageBufferType& buffer)
const
422 buffer.write(this->timeConstant);
423 buffer.write(this->influxConstant);
424 buffer.write(this->waterDensity);
425 buffer.write(this->waterViscosity);
426 buffer.write(this->dimensionless_time);
427 buffer.write(this->dimensionless_pressure);
430 template <
class MessageBufferType>
431 void CarterTracyData::read(MessageBufferType& buffer)
433 buffer.read(this->timeConstant);
434 buffer.read(this->influxConstant);
435 buffer.read(this->waterDensity);
436 buffer.read(this->waterViscosity);
437 buffer.read(this->dimensionless_time);
438 buffer.read(this->dimensionless_pressure);
441 template <
class MessageBufferType>
442 void NumericAquiferData::write(MessageBufferType& buffer)
const
444 buffer.write(this->initPressure.size());
446 for (
const auto& pressure : this->initPressure) {
447 buffer.write(pressure);
451 template <
class MessageBufferType>
452 void NumericAquiferData::read(MessageBufferType& buffer)
454 decltype(this->initPressure.size()) size{};
457 this->initPressure.resize(size, 0.0);
458 for (
auto& pressure : this->initPressure) {
459 buffer.read(pressure);
463 template <
class MessageBufferType>
464 void AquiferData::write(MessageBufferType& buffer)
const
466 buffer.write(this->aquiferID);
467 buffer.write(this->pressure);
468 buffer.write(this->fluxRate);
469 buffer.write(this->volume);
470 buffer.write(this->initPressure);
471 buffer.write(this->datumDepth);
473 this->typeData.write(buffer);
476 template <
class MessageBufferType>
477 void AquiferData::read(MessageBufferType& buffer)
479 buffer.read(this->aquiferID);
480 buffer.read(this->pressure);
481 buffer.read(this->fluxRate);
482 buffer.read(this->volume);
483 buffer.read(this->initPressure);
484 buffer.read(this->datumDepth);
486 this->typeData.read(buffer);
Class for (de-)serializing.
Definition Serializer.hpp:84
Definition Aquifer.hpp:154
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30
Definition Aquifer.hpp:317
Definition Aquifer.hpp:68
Definition Aquifer.hpp:38
Definition Aquifer.hpp:105
Definition Aquifer.hpp:132