Loading...
Searching...
No Matches
Aquifer.hpp
/*
Copyright 2019 Statoil ASA.
This file is part of the Open Porous Media project (OPM).
OPM is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OPM is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef OPM_OUTPUT_AQUIFER_HPP
#define OPM_OUTPUT_AQUIFER_HPP
#include <cstddef>
#include <map>
#include <string>
#include <unordered_map>
#include <variant>
#include <vector>
namespace Opm { namespace data {
enum class AquiferType
{
Fetkovich, CarterTracy, ConstantFlux, Numerical,
};
struct FetkovichData
{
double initVolume{};
double prodIndex{};
double timeConstant{};
bool operator==(const FetkovichData& other) const;
// MessageBufferType API should be similar to Dune::MessageBufferIF
template <class MessageBufferType>
void write(MessageBufferType& buffer) const;
// MessageBufferType API should be similar to Dune::MessageBufferIF
template <class MessageBufferType>
void read(MessageBufferType& buffer);
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(initVolume);
serializer(prodIndex);
serializer(timeConstant);
}
static FetkovichData serializationTestObject()
{
return FetkovichData{1.0, 2.0, 3.0};
}
};
struct CarterTracyData
{
double timeConstant{};
double influxConstant{};
double waterDensity{};
double waterViscosity{};
double dimensionless_time{};
double dimensionless_pressure{};
bool operator==(const CarterTracyData& other) const;
// MessageBufferType API should be similar to Dune::MessageBufferIF
template <class MessageBufferType>
void write(MessageBufferType& buffer) const;
// MessageBufferType API should be similar to Dune::MessageBufferIF
template <class MessageBufferType>
void read(MessageBufferType& buffer);
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(timeConstant);
serializer(influxConstant);
serializer(waterDensity);
serializer(waterViscosity);
serializer(dimensionless_time);
serializer(dimensionless_pressure);
}
static CarterTracyData serializationTestObject()
{
return CarterTracyData{1.0, 2.0, 3.0, 4.0, 5.0, 6.0};
}
};
struct NumericAquiferData
{
std::vector<double> initPressure{};
bool operator==(const NumericAquiferData& other) const;
// MessageBufferType API should be similar to Dune::MessageBufferIF
template <class MessageBufferType>
void write(MessageBufferType& buffer) const;
// MessageBufferType API should be similar to Dune::MessageBufferIF
template <class MessageBufferType>
void read(MessageBufferType& buffer);
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(initPressure);
}
static NumericAquiferData serializationTestObject()
{
return NumericAquiferData{{1.0, 2.0, 3.0}};
}
};
namespace detail {
template <AquiferType>
struct TypeMap;
template <> struct TypeMap<AquiferType::CarterTracy>
{
using Alternative = CarterTracyData;
};
template <> struct TypeMap<AquiferType::Fetkovich>
{
using Alternative = FetkovichData;
};
template <> struct TypeMap<AquiferType::Numerical>
{
using Alternative = NumericAquiferData;
};
template <AquiferType t>
using TypeMap_t = typename TypeMap<t>::Alternative;
} // namespace detail
class TypeSpecificData
{
private:
template <typename T>
bool is() const
{
return std::holds_alternative<T>(this->options_);
}
template <typename T>
const T* get() const
{
return this->template is<T>()
? &std::get<T>(this->options_)
: nullptr;
}
template <typename T>
T* get()
{
return this->template is<T>()
? &std::get<T>(this->options_)
: nullptr;
}
public:
TypeSpecificData() = default;
TypeSpecificData(const TypeSpecificData&) = default;
TypeSpecificData(TypeSpecificData&&) = default;
TypeSpecificData& operator=(const TypeSpecificData&) = default;
TypeSpecificData& operator=(TypeSpecificData&&) = default;
bool operator==(const TypeSpecificData& that) const
{
return std::visit(Equal{}, this->options_, that.options_);
}
template <AquiferType t>
auto* create()
{
return &this->options_.emplace<detail::TypeMap_t<t>>();
}
template <AquiferType t>
bool is() const
{
return this->template is<detail::TypeMap_t<t>>();
}
template <AquiferType t>
auto const* get() const
{
return this->template get<detail::TypeMap_t<t>>();
}
template <AquiferType t>
auto* getMutable()
{
return this->template get<detail::TypeMap_t<t>>();
}
template <typename MessageBufferType>
void write(MessageBufferType& buffer) const
{
buffer.write(this->options_.index());
std::visit(Write<MessageBufferType>{buffer}, this->options_);
}
template <typename MessageBufferType>
void read(MessageBufferType& buffer)
{
auto type = 0 * this->options_.index();
buffer.read(type);
if (type < std::variant_size_v<Types>) {
this->create(type);
std::visit(Read<MessageBufferType>{buffer}, this->options_);
}
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(options_);
}
private:
using Types = std::variant<std::monostate,
CarterTracyData,
FetkovichData,
NumericAquiferData>;
struct Equal
{
template <typename T1, typename T2>
bool operator()(const T1&, const T2&) const
{
return false;
}
template <typename T>
bool operator()(const T& e1, const T& e2) const
{
return e1 == e2;
}
bool operator()(const std::monostate&,
const std::monostate&) const
{
return true;
}
};
template <typename MessageBufferType>
class Read
{
public:
explicit Read(MessageBufferType& buffer)
: buffer_{ buffer }
{}
template <typename T>
void operator()(T& alternative)
{
return alternative.read(this->buffer_);
}
void operator()(std::monostate&)
{}
private:
MessageBufferType& buffer_;
};
template <typename MessageBufferType>
class Write
{
public:
explicit Write(MessageBufferType& buffer)
: buffer_{ buffer }
{}
template <typename T>
void operator()(const T& alternative) const
{
return alternative.write(this->buffer_);
}
void operator()(const std::monostate&) const
{}
private:
MessageBufferType& buffer_;
};
Types options_{};
void create(const std::size_t option);
};
struct AquiferData
{
int aquiferID = 0; //< One-based ID, range 1..NANAQ
double pressure = 0.0; //< Aquifer pressure
double fluxRate = 0.0; //< Aquifer influx rate (liquid aquifer)
double volume = 0.0; //< Produced liquid volume
double initPressure = 0.0; //< Aquifer's initial pressure
double datumDepth = 0.0; //< Aquifer's pressure reference depth
TypeSpecificData typeData{};
double get(const std::string& key) const;
bool operator==(const AquiferData& other) const;
// MessageBufferType API should be similar to Dune::MessageBufferIF
template <class MessageBufferType>
void write(MessageBufferType& buffer) const;
// MessageBufferType API should be similar to Dune::MessageBufferIF
template <class MessageBufferType>
void read(MessageBufferType& buffer);
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(aquiferID);
serializer(pressure);
serializer(fluxRate);
serializer(volume);
serializer(initPressure);
serializer(datumDepth);
serializer(typeData);
}
static AquiferData serializationTestObjectF()
{
auto aquifer = AquiferData {1, 123.456, 56.78, 9.0e10, 290.0, 2515.5};
auto* aquFet = aquifer.typeData.create<AquiferType::Fetkovich>();
aquFet->initVolume = 1.23;
aquFet->prodIndex = 45.67;
aquFet->timeConstant = 890.123;
return aquifer;
}
static AquiferData serializationTestObjectC()
{
auto aquifer = AquiferData {2, 123.456, 56.78, 9.0e10, 290.0, 2515.5};
auto* aquCT = aquifer.typeData.create<AquiferType::CarterTracy>();
aquCT->timeConstant = 987.65;
aquCT->influxConstant = 43.21;
aquCT->waterDensity = 1014.5;
aquCT->waterViscosity = 0.00318;
aquCT->dimensionless_time = 42.0;
aquCT->dimensionless_pressure = 2.34;
return aquifer;
}
static AquiferData serializationTestObjectN()
{
auto aquifer = AquiferData {3, 123.456, 56.78, 9.0e10, 290.0, 2515.5};
auto* aquNum = aquifer.typeData.create<AquiferType::Numerical>();
aquNum->initPressure = {1.234, 2.345, 3.4, 9.876};
return aquifer;
}
private:
using GetSummaryValue = double (AquiferData::*)() const;
using SummaryValueDispatchTable = std::unordered_map<std::string, GetSummaryValue>;
static SummaryValueDispatchTable summaryValueDispatchTable_;
double aquiferFlowRate() const;
double aquiferPressure() const;
double aquiferTotalProduction() const;
double carterTracyDimensionlessTime() const;
double carterTracyDimensionlessPressure() const;
};
// TODO: not sure what extension we will need
using Aquifers = std::map<int, AquiferData>;
template <class MessageBufferType>
void FetkovichData::write(MessageBufferType& buffer) const
{
buffer.write(this->initVolume);
buffer.write(this->prodIndex);
buffer.write(this->timeConstant);
}
template <class MessageBufferType>
void FetkovichData::read(MessageBufferType& buffer)
{
buffer.read(this->initVolume);
buffer.read(this->prodIndex);
buffer.read(this->timeConstant);
}
template <class MessageBufferType>
void CarterTracyData::write(MessageBufferType& buffer) const
{
buffer.write(this->timeConstant);
buffer.write(this->influxConstant);
buffer.write(this->waterDensity);
buffer.write(this->waterViscosity);
buffer.write(this->dimensionless_time);
buffer.write(this->dimensionless_pressure);
}
template <class MessageBufferType>
void CarterTracyData::read(MessageBufferType& buffer)
{
buffer.read(this->timeConstant);
buffer.read(this->influxConstant);
buffer.read(this->waterDensity);
buffer.read(this->waterViscosity);
buffer.read(this->dimensionless_time);
buffer.read(this->dimensionless_pressure);
}
template <class MessageBufferType>
void NumericAquiferData::write(MessageBufferType& buffer) const
{
buffer.write(this->initPressure.size());
for (const auto& pressure : this->initPressure) {
buffer.write(pressure);
}
}
template <class MessageBufferType>
void NumericAquiferData::read(MessageBufferType& buffer)
{
decltype(this->initPressure.size()) size{};
buffer.read(size);
this->initPressure.resize(size, 0.0);
for (auto& pressure : this->initPressure) {
buffer.read(pressure);
}
}
template <class MessageBufferType>
void AquiferData::write(MessageBufferType& buffer) const
{
buffer.write(this->aquiferID);
buffer.write(this->pressure);
buffer.write(this->fluxRate);
buffer.write(this->volume);
buffer.write(this->initPressure);
buffer.write(this->datumDepth);
this->typeData.write(buffer);
}
template <class MessageBufferType>
void AquiferData::read(MessageBufferType& buffer)
{
buffer.read(this->aquiferID);
buffer.read(this->pressure);
buffer.read(this->fluxRate);
buffer.read(this->volume);
buffer.read(this->initPressure);
buffer.read(this->datumDepth);
this->typeData.read(buffer);
}
}} // Opm::data
#endif // OPM_OUTPUT_AQUIFER_HPP
Opm::Serializer
Class for (de-)serializing.
Definition Serializer.hpp:91
Opm::data::TypeSpecificData
Definition Aquifer.hpp:154
Opm
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30
Opm::data::AquiferData
Definition Aquifer.hpp:317
Opm::data::CarterTracyData
Definition Aquifer.hpp:68
Opm::data::FetkovichData
Definition Aquifer.hpp:38
Opm::data::NumericAquiferData
Definition Aquifer.hpp:105
Opm::data::detail::TypeMap
Definition Aquifer.hpp:132