Loading...
Searching...
No Matches
FlatTable.hpp
#ifndef OPM_FLAT_TABLE_HPP
#define OPM_FLAT_TABLE_HPP
#include <cstddef>
#include <initializer_list>
#include <string_view>
#include <vector>
namespace Opm {
class DeckKeyword;
template< typename T >
struct FlatTable : public std::vector< T > {
FlatTable() = default;
explicit FlatTable( const DeckKeyword& );
explicit FlatTable(const std::vector<T>& data) :
std::vector<T>(data)
{}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(static_cast<std::vector<T>&>(*this));
}
};
template <typename RecordType>
class FlatTableWithCopy
{
public:
FlatTableWithCopy() = default;
explicit FlatTableWithCopy(const DeckKeyword& kw,
std::string_view expect = "");
explicit FlatTableWithCopy(std::initializer_list<RecordType> records);
auto size() const { return this->table_.size(); }
bool empty() const { return this->table_.empty(); }
auto begin() const { return this->table_.begin(); }
auto end() const { return this->table_.end(); }
const RecordType& operator[](const std::size_t tableID) const
{
return this->table_[tableID];
}
const RecordType& at(const std::size_t tableID) const
{
return this->table_.at(tableID);
}
bool operator==(const FlatTableWithCopy& other) const
{
return this->table_ == other.table_;
}
template <class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(this->table_);
}
protected:
std::vector<RecordType> table_{};
};
struct GRAVITYRecord {
static constexpr std::size_t size = 3;
double oil_api;
double water_sg;
double gas_sg;
bool operator==(const GRAVITYRecord& data) const {
return this->oil_api == data.oil_api &&
this->water_sg == data.water_sg &&
this->gas_sg == data.gas_sg;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(this->oil_api);
serializer(this->water_sg);
serializer(this->gas_sg);
}
};
struct GravityTable : public FlatTableWithCopy<GRAVITYRecord>
{
GravityTable() = default;
explicit GravityTable(const DeckKeyword& kw);
explicit GravityTable(std::initializer_list<GRAVITYRecord> records);
static GravityTable serializationTestObject()
{
return GravityTable({{1.0, 2.0, 3.0}});
}
};
struct DENSITYRecord {
static constexpr std::size_t size = 3;
double oil;
double water;
double gas;
bool operator==(const DENSITYRecord& data) const {
return oil == data.oil &&
water == data.water &&
gas == data.gas;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(oil);
serializer(water);
serializer(gas);
}
};
struct DensityTable : public FlatTableWithCopy<DENSITYRecord>
{
DensityTable() = default;
explicit DensityTable(const DeckKeyword& kw);
explicit DensityTable(const GravityTable& gravity);
explicit DensityTable(std::initializer_list<DENSITYRecord> records);
static DensityTable serializationTestObject()
{
return DensityTable({{1.0, 2.0, 3.0}});
}
};
struct DiffCoeffRecord {
static constexpr std::size_t size = 8;
double oil_mw;
double gas_mw;
double gas_in_gas;
double oil_in_gas;
double gas_in_oil;
double oil_in_oil;
double gas_in_oil_cross_phase;
double oil_in_oil_cross_phase;
bool operator==(const DiffCoeffRecord& data) const {
return oil_mw == data.oil_mw &&
gas_mw == data.gas_mw &&
gas_in_gas == data.gas_in_gas &&
oil_in_gas == data.oil_in_gas &&
gas_in_oil == data.gas_in_oil &&
oil_in_oil == data.oil_in_oil &&
gas_in_oil_cross_phase == data.gas_in_oil_cross_phase &&
oil_in_oil_cross_phase == data.oil_in_oil_cross_phase;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(oil_mw);
serializer(gas_mw);
serializer(gas_in_gas);
serializer(oil_in_gas);
serializer(gas_in_oil);
serializer(oil_in_oil);
serializer(gas_in_oil_cross_phase);
serializer(oil_in_oil_cross_phase);
}
};
struct DiffCoeffTable : public FlatTable< DiffCoeffRecord > {
using FlatTable< DiffCoeffRecord >::FlatTable;
static DiffCoeffTable serializationTestObject()
{
return DiffCoeffTable({{1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0}});
}
};
struct DiffCoeffWatRecord {
static constexpr std::size_t size = 2;
// hardcoded to 2 components
double co2_in_water;
double h2o_in_water;
bool operator==(const DiffCoeffWatRecord& data) const {
return co2_in_water == data.co2_in_water &&
h2o_in_water == data.h2o_in_water;}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(co2_in_water);
serializer(h2o_in_water);
}
};
struct DiffCoeffWatTable : public FlatTable< DiffCoeffWatRecord > {
using FlatTable< DiffCoeffWatRecord >::FlatTable;
static DiffCoeffWatTable serializationTestObject()
{
return DiffCoeffWatTable({{1.0, 2.0}});
}
};
struct DiffCoeffGasRecord {
static constexpr std::size_t size = 2;
// hardcoded to 2 components
double co2_in_gas;
double h2o_in_gas;
bool operator==(const DiffCoeffGasRecord& data) const {
return co2_in_gas == data.co2_in_gas &&
h2o_in_gas == data.h2o_in_gas;}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(co2_in_gas);
serializer(h2o_in_gas);
}
};
struct DiffCoeffGasTable : public FlatTable< DiffCoeffGasRecord > {
using FlatTable< DiffCoeffGasRecord >::FlatTable;
static DiffCoeffGasTable serializationTestObject()
{
return DiffCoeffGasTable({{1.0, 2.0}});
}
};
struct PVTWRecord {
static constexpr std::size_t size = 5;
double reference_pressure;
double volume_factor;
double compressibility;
double viscosity;
double viscosibility;
bool operator==(const PVTWRecord& data) const {
return reference_pressure == data.reference_pressure &&
volume_factor == data.volume_factor &&
compressibility == data.compressibility &&
viscosity == data.viscosity &&
viscosibility == data.viscosibility;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(reference_pressure);
serializer(volume_factor);
serializer(compressibility);
serializer(viscosity);
serializer(viscosibility);
}
};
struct PvtwTable : public FlatTableWithCopy<PVTWRecord>
{
PvtwTable() = default;
explicit PvtwTable(const DeckKeyword& kw);
explicit PvtwTable(std::initializer_list<PVTWRecord> records);
static PvtwTable serializationTestObject()
{
return PvtwTable({{1.0, 2.0, 3.0, 4.0, 5.0}});
}
};
struct ROCKRecord {
static constexpr std::size_t size = 2;
double reference_pressure;
double compressibility;
bool operator==(const ROCKRecord& data) const {
return reference_pressure == data.reference_pressure &&
compressibility == data.compressibility;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(reference_pressure);
serializer(compressibility);
}
};
struct RockTable : public FlatTableWithCopy<ROCKRecord>
{
RockTable() = default;
explicit RockTable(const DeckKeyword& kw);
explicit RockTable(std::initializer_list<ROCKRecord> records);
static RockTable serializationTestObject()
{
return RockTable({{1.0, 2.0}});
}
};
struct PVCDORecord {
static constexpr std::size_t size = 5;
double reference_pressure;
double volume_factor;
double compressibility;
double viscosity;
double viscosibility;
bool operator==(const PVCDORecord& data) const {
return reference_pressure == data.reference_pressure &&
volume_factor == data.volume_factor &&
compressibility == data.compressibility &&
viscosity == data.viscosity &&
viscosibility == data.viscosibility;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(reference_pressure);
serializer(volume_factor);
serializer(compressibility);
serializer(viscosity);
serializer(viscosibility);
}
};
struct PvcdoTable : public FlatTable< PVCDORecord > {
using FlatTable< PVCDORecord >::FlatTable;
static PvcdoTable serializationTestObject()
{
return PvcdoTable({{1.0, 2.0, 3.0, 4.0, 5.0}});
}
};
struct PlmixparRecord {
static constexpr std::size_t size = 1;
double todd_langstaff;
bool operator==(const PlmixparRecord& data) const {
return todd_langstaff == data.todd_langstaff;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(todd_langstaff);
}
};
struct PlmixparTable : public FlatTable< PlmixparRecord> {
using FlatTable< PlmixparRecord >::FlatTable;
static PlmixparTable serializationTestObject()
{
return PlmixparTable({PlmixparRecord{1.0}});
}
};
struct PlyvmhRecord {
static constexpr std::size_t size = 4;
double k_mh;
double a_mh;
double gamma;
double kappa;
bool operator==(const PlyvmhRecord& data) const {
return k_mh == data.k_mh &&
a_mh == data.a_mh &&
gamma == data.gamma &&
kappa == data.kappa;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(k_mh);
serializer(a_mh);
serializer(gamma);
serializer(kappa);
}
};
struct PlyvmhTable : public FlatTable<PlyvmhRecord> {
using FlatTable< PlyvmhRecord >::FlatTable;
static PlyvmhTable serializationTestObject()
{
return PlyvmhTable({{1.0, 2.0, 3.0, 4.0}});
}
};
struct ShrateRecord {
static constexpr std::size_t size = 1;
double rate;
bool operator==(const ShrateRecord& data) const {
return rate == data.rate;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(rate);
}
};
struct ShrateTable : public FlatTable<ShrateRecord> {
using FlatTable< ShrateRecord >::FlatTable;
static ShrateTable serializationTestObject()
{
return ShrateTable({ShrateRecord{1.0}});
}
};
struct Stone1exRecord {
static constexpr std::size_t size = 1;
double eta;
bool operator==(const Stone1exRecord& data) const {
return eta == data.eta;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(eta);
}
};
struct Stone1exTable : public FlatTable<Stone1exRecord> {
using FlatTable< Stone1exRecord >::FlatTable;
static Stone1exTable serializationTestObject()
{
return Stone1exTable({Stone1exRecord{1.0}});
}
};
struct TlmixparRecord {
static constexpr std::size_t size = 2;
double viscosity;
double density;
bool operator==(const TlmixparRecord& data) const {
return viscosity == data.viscosity &&
density == data.density;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(viscosity);
serializer(density);
}
};
struct TlmixparTable : public FlatTable< TlmixparRecord> {
using FlatTable< TlmixparRecord >::FlatTable;
static TlmixparTable serializationTestObject()
{
return TlmixparTable({{1.0, 2.0}});
}
};
struct VISCREFRecord {
static constexpr std::size_t size = 2;
double reference_pressure;
double reference_rs;
bool operator==(const VISCREFRecord& data) const {
return reference_pressure == data.reference_pressure &&
reference_rs == data.reference_rs;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(reference_pressure);
serializer(reference_rs);
}
};
struct ViscrefTable : public FlatTable< VISCREFRecord > {
using FlatTable< VISCREFRecord >::FlatTable;
static ViscrefTable serializationTestObject()
{
return ViscrefTable({{1.0, 2.0}});
}
};
struct WATDENTRecord {
static constexpr std::size_t size = 3;
double reference_temperature;
double first_coefficient;
double second_coefficient;
bool operator==(const WATDENTRecord& data) const {
return reference_temperature == data.reference_temperature &&
first_coefficient == data.first_coefficient &&
second_coefficient == data.second_coefficient;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(reference_temperature);
serializer(first_coefficient);
serializer(second_coefficient);
}
};
struct WatdentTable : public FlatTable< WATDENTRecord > {
using FlatTable< WATDENTRecord >::FlatTable;
static WatdentTable serializationTestObject()
{
return WatdentTable({{1.0, 2.0, 3.0}});
}
};
struct SatFuncLETRecord {
static constexpr std::size_t size = 17;
double s1_residual;
double s1_critical;
double l1_relperm;
double e1_relperm;
double t1_relperm;
double krt1_relperm;
double s2_residual;
double s2_critical;
double l2_relperm;
double e2_relperm;
double t2_relperm;
double krt2_relperm;
double l_pc;
double e_pc;
double t_pc;
double pcir_pc;
double pct_pc;
bool operator==(const SatFuncLETRecord& data) const {
return s1_residual == data.s1_residual &&
s1_critical == data.s1_critical &&
l1_relperm == data.l1_relperm &&
e1_relperm == data.e1_relperm &&
t1_relperm == data.t1_relperm &&
krt1_relperm == data.krt1_relperm &&
s2_residual == data.s2_residual &&
s2_critical == data.s2_critical &&
l2_relperm == data.l2_relperm &&
e2_relperm == data.e2_relperm &&
t2_relperm == data.t2_relperm &&
krt2_relperm == data.krt2_relperm &&
l_pc == data.l_pc &&
e_pc == data.e_pc &&
t_pc == data.t_pc &&
pcir_pc == data.pcir_pc &&
pct_pc == data.pct_pc;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(s1_residual);
serializer(s1_critical);
serializer(l1_relperm);
serializer(e1_relperm);
serializer(t1_relperm);
serializer(krt1_relperm);
serializer(s2_residual);
serializer(s2_critical);
serializer(l2_relperm);
serializer(e2_relperm);
serializer(t2_relperm);
serializer(krt2_relperm);
serializer(l_pc);
serializer(e_pc);
serializer(t_pc);
serializer(pcir_pc);
serializer(pct_pc);
}
};
struct SwofletTable : public FlatTable< SatFuncLETRecord > {
using FlatTable< SatFuncLETRecord >::FlatTable;
static SwofletTable serializationTestObject()
{
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}});
}
};
struct SgofletTable : public FlatTable< SatFuncLETRecord > {
using FlatTable< SatFuncLETRecord >::FlatTable;
static SgofletTable serializationTestObject()
{
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}});
}
};
}
#endif //OPM_FLAT_TABLE_HPP
Opm::DeckKeyword
Definition DeckKeyword.hpp:36
Opm::FlatTableWithCopy
Definition FlatTable.hpp:30
Opm::Serializer
Class for (de-)serializing.
Definition Serializer.hpp:91
Opm
This class implements a small container which holds the transmissibility mulitpliers for all the face...
Definition Exceptions.hpp:30
Opm::DENSITYRecord
Definition FlatTable.hpp:101
Opm::DensityTable
Definition FlatTable.hpp:124
Opm::DiffCoeffGasRecord
Definition FlatTable.hpp:211
Opm::DiffCoeffGasTable
Definition FlatTable.hpp:230
Opm::DiffCoeffRecord
Definition FlatTable.hpp:136
Opm::DiffCoeffTable
Definition FlatTable.hpp:173
Opm::DiffCoeffWatRecord
Definition FlatTable.hpp:183
Opm::DiffCoeffWatTable
Definition FlatTable.hpp:202
Opm::FlatTable
Definition FlatTable.hpp:14
Opm::GRAVITYRecord
Definition FlatTable.hpp:67
Opm::GravityTable
Definition FlatTable.hpp:90
Opm::PVCDORecord
Definition FlatTable.hpp:310
Opm::PVTWRecord
Definition FlatTable.hpp:239
Opm::PlmixparRecord
Definition FlatTable.hpp:347
Opm::PlmixparTable
Definition FlatTable.hpp:363
Opm::PlyvmhRecord
Definition FlatTable.hpp:372
Opm::PlyvmhTable
Definition FlatTable.hpp:397
Opm::PvcdoTable
Definition FlatTable.hpp:338
Opm::PvtwTable
Definition FlatTable.hpp:268
Opm::ROCKRecord
Definition FlatTable.hpp:279
Opm::RockTable
Definition FlatTable.hpp:299
Opm::SatFuncLETRecord
Definition FlatTable.hpp:543
Opm::SgofletTable
Definition FlatTable.hpp:617
Opm::ShrateRecord
Definition FlatTable.hpp:406
Opm::ShrateTable
Definition FlatTable.hpp:422
Opm::Stone1exRecord
Definition FlatTable.hpp:431
Opm::Stone1exTable
Definition FlatTable.hpp:447
Opm::SwofletTable
Definition FlatTable.hpp:607
Opm::TlmixparRecord
Definition FlatTable.hpp:456
Opm::TlmixparTable
Definition FlatTable.hpp:475
Opm::VISCREFRecord
Definition FlatTable.hpp:484
Opm::ViscrefTable
Definition FlatTable.hpp:503
Opm::WATDENTRecord
Definition FlatTable.hpp:512
Opm::WatdentTable
Definition FlatTable.hpp:534