OilfieldToolsNet/opm-common
4
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #1597 from akva2/serialize_internal_eclstate_part5

Browse Source 
Internal serialization in EclipseState - part 5
This commit is contained in:
Arne Morten Kvarving 2020-03-17 13:59:03 +01:00 committed by GitHub
commit 3f4ff89b01
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
38 changed files with 476 additions and 131 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
opm/parser/eclipse/EclipseState/Aquancon.hpp
View File

@ -66,6 +66,15 @@ namespace Opm {
this->face_dir == other.face_dir;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(aquiferID);
serializer(global_index);
serializer(influx_coeff);
serializer(influx_mult);
serializer(face_dir);
}
};
@ -78,8 +87,14 @@ namespace Opm {
bool active() const;
const std::vector<Aquancon::AquancCell> operator[](int aquiferID) const;
private:
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer.map(cells);
}
private:
static bool cellInsideReservoirAndActive(const EclipseGrid& grid, int i, int j, int k);
static bool neighborCellInsideReservoirAndActive(const EclipseGrid& grid, int i, int j, int k, FaceDir::DirEnum faceDir);

29
opm/parser/eclipse/EclipseState/AquiferCT.hpp
View File

@ -83,7 +83,29 @@ namespace Opm {
std::vector<int> cell_id;
bool operator==(const AQUCT_data& other) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(aquiferID);
serializer(inftableID);
serializer(pvttableID);
serializer(phi_aq);
serializer(d0);
serializer(C_t);
serializer(r_o);
serializer(k_a);
serializer(c1);
serializer(h);
serializer(theta);
serializer(c2);
serializer(p0);
serializer(td);
serializer(pi);
serializer(cell_id);
}
};
AquiferCT() = default;
AquiferCT(const TableManager& tables, const Deck& deck);
AquiferCT(const std::vector<AquiferCT::AQUCT_data>& data);
@ -93,6 +115,13 @@ namespace Opm {
std::vector<AquiferCT::AQUCT_data>::const_iterator end() const;
const std::vector<AquiferCT::AQUCT_data>& data() const;
bool operator==(const AquiferCT& other) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer.vector(m_aquct);
}
private:
std::vector<AquiferCT::AQUCT_data> m_aquct;
};

9
opm/parser/eclipse/EclipseState/AquiferConfig.hpp
View File

@ -41,6 +41,15 @@ public:
const Aquifetp& fetp() const;
const Aquancon& connections() const;
bool operator==(const AquiferConfig& other);
template<class Serializer>
void serializeOp(Serializer& serializer)
{
aquifetp.serializeOp(serializer);
aquiferct.serializeOp(serializer);
aqconn.serializeOp(serializer);
}
private:
Aquifetp aquifetp;
AquiferCT aquiferct;

19
opm/parser/eclipse/EclipseState/Aquifetp.hpp
View File

@ -49,6 +49,18 @@ class Aquifetp {
V0, // initial volume of water in aquifer
d0; // aquifer datum depth
std::pair<bool, double> p0;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(aquiferID);
serializer(pvttableID);
serializer(J);
serializer(C_t);
serializer(V0);
serializer(d0);
serializer(p0);
}
};
Aquifetp() = default;
@ -60,6 +72,13 @@ class Aquifetp {
std::vector<Aquifetp::AQUFETP_data>::const_iterator begin() const;
std::vector<Aquifetp::AQUFETP_data>::const_iterator end() const;
bool operator==(const Aquifetp& other) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer.vector(m_aqufetp);
}
private:
std::vector<Aquifetp::AQUFETP_data> m_aqufetp;
};

4
opm/parser/eclipse/EclipseState/EclipseState.hpp
View File

@ -118,7 +118,7 @@ namespace Opm {
void serializeOp(Serializer& serializer)
{
// FieldPropsManager is handled otherwise, do not add
serializer(m_tables);
m_tables.serializeOp(serializer);
m_runspec.serializeOp(serializer);
m_eclipseConfig.serializeOp(serializer);
serializer(m_deckUnitSystem);
@ -129,7 +129,7 @@ namespace Opm {
m_transMult.serializeOp(serializer);
m_faults.serializeOp(serializer);
serializer(m_title);
serializer(aquifer_config);
aquifer_config.serializeOp(serializer);
}
private:

13
opm/parser/eclipse/EclipseState/Tables/Aqudims.hpp
View File

@ -127,6 +127,19 @@ namespace Opm {
m_mxaaql == data.m_mxaaql;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_mxnaqn);
serializer(m_mxnaqc);
serializer(m_niftbl);
serializer(m_nriftb);
serializer(m_nanaqu);
serializer(m_ncamax);
serializer(m_mxnali);
serializer(m_mxaaql);
}
private:
size_t m_mxnaqn , m_mxnaqc , m_niftbl , m_nriftb , m_nanaqu , m_ncamax , m_mxnali , m_mxaaql;

6
opm/parser/eclipse/EclipseState/Tables/BrineDensityTable.hpp
View File

@ -46,6 +46,12 @@ namespace Opm {
return this->m_tableValues.size();
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_tableValues);
}
private:
std::vector<double> m_tableValues;
};

10
opm/parser/eclipse/EclipseState/Tables/ColumnSchema.hpp
View File

@ -34,7 +34,6 @@ namespace Opm {
ColumnSchema(const std::string& name , Table::ColumnOrderEnum order, Table::DefaultAction defaultAction);
ColumnSchema(const std::string& name , Table::ColumnOrderEnum order, double defaultValue);
const std::string& name() const;
Table::ColumnOrderEnum order() const;
bool validOrder( double value1 , double value2) const;
bool lookupValid( ) const;
bool acceptsDefault( ) const;
@ -45,6 +44,15 @@ namespace Opm {
bool operator==(const ColumnSchema& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_name);
serializer(m_order);
serializer(m_defaultAction);
serializer(m_defaultValue);
}
private:
std::string m_name;
Table::ColumnOrderEnum m_order;

16
opm/parser/eclipse/EclipseState/Tables/DenT.hpp
View File

@ -39,8 +39,15 @@ namespace Opm {
entry(double T0_, double C1_, double C2_);
explicit entry(const DeckRecord& record);
bool operator==(const entry& other) const;
};
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(T0);
serializer(C1);
serializer(C2);
}
};
DenT() = default;
explicit DenT(const DeckKeyword& keyword);
@ -50,6 +57,13 @@ namespace Opm {
const entry& operator[](const std::size_t index) const;
bool operator==(const DenT& other) const;
std::size_t size() const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer.vector(m_records);
}
private:
std::vector<entry> m_records;
};

11
opm/parser/eclipse/EclipseState/Tables/Eqldims.hpp
View File

@ -82,6 +82,17 @@ namespace Opm {
this->getNumTracerTables() == data.getNumTracerTables() &&
this->getNumDepthNodesTracer() == data.getNumDepthNodesTracer();
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_ntequl);
serializer(m_depth_nodes_p);
serializer(m_depth_nodes_tab);
serializer(m_nttrvd);
serializer(m_nstrvd);
}
private:
size_t m_ntequl , m_depth_nodes_p , m_depth_nodes_tab , m_nttrvd , m_nstrvd;

89
opm/parser/eclipse/EclipseState/Tables/FlatTable.hpp
View File

@ -12,6 +12,12 @@ struct FlatTable : public std::vector< T > {
explicit FlatTable(const std::vector<T>& data) :
std::vector<T>(data)
{}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer.vector(*this);
}
};
struct DENSITYRecord {
@ -26,6 +32,14 @@ struct DENSITYRecord {
water == data.water &&
gas == data.gas;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(oil);
serializer(water);
serializer(gas);
}
};
struct DensityTable : public FlatTable< DENSITYRecord > {
@ -48,6 +62,16 @@ struct PVTWRecord {
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 FlatTable< PVTWRecord > {
@ -65,6 +89,12 @@ struct ROCKRecord {
compressibility == data.compressibility;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(reference_pressure);
serializer(compressibility);
}
};
struct RockTable : public FlatTable< ROCKRecord > {
@ -87,6 +117,16 @@ struct PVCDORecord {
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 > {
@ -101,6 +141,12 @@ struct PlmixparRecord {
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> {
@ -121,6 +167,15 @@ struct PlyvmhRecord {
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> {
@ -135,6 +190,12 @@ struct ShrateRecord {
bool operator==(const ShrateRecord& data) const {
return rate == data.rate;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(rate);
}
};
struct ShrateTable : public FlatTable<ShrateRecord> {
@ -149,6 +210,12 @@ struct Stone1exRecord {
bool operator==(const Stone1exRecord& data) const {
return eta == data.eta;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(eta);
}
};
struct Stone1exTable : public FlatTable<Stone1exRecord> {
@ -165,6 +232,13 @@ struct TlmixparRecord {
return viscosity == data.viscosity &&
density == data.density;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(viscosity);
serializer(density);
}
};
struct TlmixparTable : public FlatTable< TlmixparRecord> {
@ -181,6 +255,13 @@ struct VISCREFRecord {
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 > {
@ -199,6 +280,14 @@ struct WATDENTRecord {
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 > {

11
opm/parser/eclipse/EclipseState/Tables/JFunc.hpp
View File

@ -46,6 +46,17 @@ public:
bool operator==(const JFunc& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_flag);
serializer(m_owSurfaceTension);
serializer(m_goSurfaceTension);
serializer(m_alphaFactor);
serializer(m_betaFactor);
serializer(m_direction);
}
private:
Flag m_flag; // JFUNC flag: WATER, GAS, or BOTH. Default BOTH
double m_owSurfaceTension; // oil-wat surface tension. Required if flag is BOTH or WATER

11
opm/parser/eclipse/EclipseState/Tables/PlyshlogTable.hpp
View File

@ -58,6 +58,17 @@ namespace Opm {
bool operator==(const PlyshlogTable& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
this->SimpleTable::serializeOp(serializer);
serializer(m_refPolymerConcentration);
serializer(m_refSalinity);
serializer(m_refTemperature);
serializer(m_hasRefSalinity);
serializer(m_hasRefTemperature);
}
private:
double m_refPolymerConcentration = 1.0;
double m_refSalinity = 0.0;

9
opm/parser/eclipse/EclipseState/Tables/PolyInjTable.hpp
View File

@ -58,6 +58,15 @@ namespace Opm {
bool operator==(const PolyInjTable& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_throughputs);
serializer(m_velocities);
serializer(m_table_number);
serializer(m_data);
}
protected:
std::vector<double> m_throughputs;
std::vector<double> m_velocities;

8
opm/parser/eclipse/EclipseState/Tables/PvtwsaltTable.hpp
View File

@ -45,6 +45,14 @@ namespace Opm {
bool operator==(const PvtwsaltTable& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_pRefValues);
serializer(m_saltConsRefValues);
serializer(m_tableValues);
}
protected:
double m_pRefValues;

18
opm/parser/eclipse/EclipseState/Tables/PvtxTable.hpp
View File

@ -128,12 +128,6 @@ The first row actually corresponds to saturated values.
double getArgValue(size_t index) const;
const SimpleTable& getSaturatedTable() const;
const ColumnSchema& getOuterColumnSchema() const;
const TableColumn& getOuterColumn() const;
const TableSchema& getUnderSaturatedSchema() const;
const TableSchema& getSaturatedSchema() const;
const std::vector<SimpleTable>& getUnderSaturatedTables() const;
/*
Will iterate over the internal undersaturated tables; same
as getUnderSaturatedTable( ).
@ -142,6 +136,18 @@ The first row actually corresponds to saturated values.
std::vector< SimpleTable >::const_iterator end() const;
bool operator==(const PvtxTable& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
m_outerColumnSchema.serializeOp(serializer);
m_outerColumn.serializeOp(serializer);
m_underSaturatedSchema.serializeOp(serializer);
m_saturatedSchema.serializeOp(serializer);
serializer.vector(m_underSaturatedTables);
m_saturatedTable.serializeOp(serializer);
}
protected:
ColumnSchema m_outerColumnSchema;
TableColumn m_outerColumn;

9
opm/parser/eclipse/EclipseState/Tables/Regdims.hpp
View File

@ -80,6 +80,15 @@ namespace Opm {
this->getNPLMIX() == data.getNPLMIX();
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_NTFIP);
serializer(m_NMFIPR);
serializer(m_NRFREG);
serializer(m_NTFREG);
serializer(m_NPLMIX);
}
private:
size_t m_NTFIP;

13
opm/parser/eclipse/EclipseState/Tables/Rock2dTable.hpp
View File

@ -36,14 +36,15 @@ namespace Opm {
double getPressureValue(size_t index) const;
double getPvmultValue(size_t pressureIndex, size_t saturationIndex ) const;
const std::vector<std::vector<double>>& pvmultValues() const
{ return m_pvmultValues; }
const std::vector<double>& pressureValues() const
{ return m_pressureValues; }
bool operator==(const Rock2dTable& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_pvmultValues);
serializer(m_pressureValues);
}
protected:
std::vector< std::vector <double> > m_pvmultValues;
std::vector< double > m_pressureValues;

13
opm/parser/eclipse/EclipseState/Tables/Rock2dtrTable.hpp
View File

@ -36,14 +36,15 @@ namespace Opm {
double getPressureValue(size_t index) const;
double getTransMultValue(size_t pressureIndex, size_t saturationIndex ) const;
const std::vector<std::vector<double>>& transMultValues() const
{ return m_transMultValues; }
const std::vector<double>& pressureValues() const
{ return m_pressureValues; }
bool operator==(const Rock2dtrTable& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_transMultValues);
serializer(m_pressureValues);
}
protected:
std::vector< std::vector <double> > m_transMultValues;
std::vector< double > m_pressureValues;

9
opm/parser/eclipse/EclipseState/Tables/RocktabTable.hpp
View File

@ -42,10 +42,15 @@ namespace Opm {
const TableColumn& getTransmissibilityMultiplierYColumn() const;
const TableColumn& getTransmissibilityMultiplierZColumn() const;
bool isDirectional() const;
bool operator==(const RocktabTable& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
this->SimpleTable::serializeOp(serializer);
serializer(m_isDirectional);
}
private:
bool m_isDirectional = false;
};

11
opm/parser/eclipse/EclipseState/Tables/SimpleTable.hpp
View File

@ -42,9 +42,6 @@ namespace Opm {
bool jfunc);
explicit SimpleTable( TableSchema );
const TableSchema& schema() const;
const OrderedMap<std::string, TableColumn>& columns() const;
bool jfunc() const;
void addColumns();
void init(const DeckItem& deckItem );
size_t numColumns() const;
@ -72,6 +69,14 @@ namespace Opm {
bool operator==(const SimpleTable& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
m_schema.serializeOp(serializer);
m_columns.serializeOp(serializer);
serializer(m_jfunc);
}
protected:
TableSchema m_schema;
OrderedMap<std::string, TableColumn> m_columns;

8
opm/parser/eclipse/EclipseState/Tables/SkprpolyTable.hpp
View File

@ -37,12 +37,18 @@ namespace Opm {
explicit SkprpolyTable(const DeckKeyword& table);
double referenceConcentration() const;
void setReferenceConcentration(double refConcentration);
const std::vector<std::vector<double>>& getSkinPressures() const;
bool operator==(const SkprpolyTable& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
this->PolyInjTable::serializeOp(serializer);
serializer(m_ref_polymer_concentration);
}
private:
double m_ref_polymer_concentration;

6
opm/parser/eclipse/EclipseState/Tables/SolventDensityTable.hpp
View File

@ -45,6 +45,12 @@ namespace Opm {
return this->m_tableValues.size();
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_tableValues);
}
private:
std::vector<double> m_tableValues;
};

8
opm/parser/eclipse/EclipseState/Tables/StandardCond.hpp
View File

@ -33,9 +33,15 @@ namespace Opm {
pressure == data.pressure;
}
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(temperature);
serializer(pressure);
}
double temperature;
double pressure;
};
}

14
opm/parser/eclipse/EclipseState/Tables/TableColumn.hpp
View File

@ -39,11 +39,7 @@ namespace Opm {
const std::vector<bool>& defaults,
size_t defaultCount);
size_t size( ) const;
const ColumnSchema& schema() const;
const std::string& name() const;
const std::vector<double>& values() const;
const std::vector<bool>& defaults() const;
size_t defaultCount() const;
void assertOrder(double value1 , double value2) const;
void addValue(double);
void addDefault();
@ -73,6 +69,16 @@ namespace Opm {
bool operator==(const TableColumn& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
m_schema.serializeOp(serializer);
serializer(m_name);
serializer(m_values);
serializer(m_default);
serializer(m_defaultCount);
}
private:
void assertUpdate(size_t index, double value) const;
void assertPrevious(size_t index , double value) const;

7
opm/parser/eclipse/EclipseState/Tables/TableContainer.hpp
View File

@ -92,6 +92,13 @@ namespace Opm {
bool operator==(const TableContainer& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
serializer(m_maxTables);
serializer.map(m_tables);
}
private:
size_t m_maxTables;
TableMap m_tables;

77
opm/parser/eclipse/EclipseState/Tables/TableManager.hpp
View File

@ -34,8 +34,10 @@
#include <opm/parser/eclipse/EclipseState/Tables/DenT.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/PvtgTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/PvtoTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/RocktabTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/Rock2dTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/Rock2dtrTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/PlyshlogTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/PvtwsaltTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/BrineDensityTable.hpp>
#include <opm/parser/eclipse/EclipseState/Tables/SolventDensityTable.hpp>
@ -213,6 +215,72 @@ namespace Opm {
double rtemp() const;
bool operator==(const TableManager& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
auto simpleTables = m_simpleTables;
auto split = splitSimpleTable(simpleTables);
serializer.map(simpleTables);
serializer(split.plyshMax);
serializer.map(split.plyshMap);
serializer(split.rockMax);
serializer.map(split.rockMap);
serializer.vector(m_pvtgTables);
serializer.vector(m_pvtoTables);
serializer.vector(m_rock2dTables);
serializer.vector(m_rock2dtrTables);
m_pvtwTable.serializeOp(serializer);
m_pvcdoTable.serializeOp(serializer);
m_densityTable.serializeOp(serializer);
m_plyvmhTable.serializeOp(serializer);
m_rockTable.serializeOp(serializer);
m_plmixparTable.serializeOp(serializer);
m_shrateTable.serializeOp(serializer);
m_stone1exTable.serializeOp(serializer);
m_tlmixparTable.serializeOp(serializer);
m_viscrefTable.serializeOp(serializer);
m_watdentTable.serializeOp(serializer);
serializer.vector(m_pvtwsaltTables);
serializer.vector(m_bdensityTables);
serializer.vector(m_sdensityTables);
serializer.map(m_plymwinjTables);
serializer.map(m_skprwatTables);
serializer.map(m_skprpolyTables);
m_tabdims.serializeOp(serializer);
m_regdims.serializeOp(serializer);
m_eqldims.serializeOp(serializer);
m_aqudims.serializeOp(serializer);
serializer(hasImptvd);
serializer(hasEnptvd);
serializer(hasEqlnum);
serializer(hasShrate);
serializer(jfunc);
oilDenT.serializeOp(serializer);
gasDenT.serializeOp(serializer);
watDenT.serializeOp(serializer);
stcond.serializeOp(serializer);
serializer(m_gas_comp_index);
serializer(m_rtemp);
if (!serializer.isSerializing()) {
m_simpleTables = simpleTables;
if (split.plyshMax > 0) {
TableContainer container(split.plyshMax);
for (const auto& it : split.plyshMap) {
container.addTable(it.first, it.second);
}
m_simpleTables.insert(std::make_pair("PLYSHLOG", container));
}
if (split.rockMax > 0) {
TableContainer container(split.rockMax);
for (const auto& it : split.rockMap) {
container.addTable(it.first, it.second);
}
m_simpleTables.insert(std::make_pair("ROCKTAB", container));
}
}
}
private:
TableContainer& forceGetTables( const std::string& tableName , size_t numTables);
@ -469,6 +537,15 @@ namespace Opm {
StandardCond stcond;
std::size_t m_gas_comp_index;
double m_rtemp;
struct SplitSimpleTables {
size_t plyshMax = 0;
size_t rockMax = 0;
std::map<size_t, std::shared_ptr<PlyshlogTable>> plyshMap;
std::map<size_t, std::shared_ptr<RocktabTable>> rockMap;
};
SplitSimpleTables splitSimpleTable(std::map<std::string,TableContainer>& simpleTables);
};
}

9
opm/parser/eclipse/EclipseState/Tables/TableSchema.hpp
View File

@ -37,12 +37,17 @@ namespace Opm {
const ColumnSchema& getColumn( size_t columnIndex ) const;
bool hasColumn(const std::string&) const;
const OrderedMap<std::string, ColumnSchema>& getColumns() const;
/* Number of columns */
size_t size() const;
bool operator==(const TableSchema& data) const;
template<class Serializer>
void serializeOp(Serializer& serializer)
{
m_columns.serializeOp(serializer);
}
private:
OrderedMap<std::string, ColumnSchema> m_columns;
};

10
src/opm/parser/eclipse/EclipseState/Tables/ColumnSchema.cpp
View File

@ -52,10 +52,6 @@ namespace Opm {
return m_name;
}
Table::ColumnOrderEnum ColumnSchema::order() const {
return m_order;
}
bool ColumnSchema::validOrder( double value1 , double value2) const {
switch (m_order) {
case Table::RANDOM:
@ -124,13 +120,9 @@ namespace Opm {
bool ColumnSchema::operator==(const ColumnSchema& data) const {
return this->name() == data.name() &&
this->order() == data.order() &&
this->m_order == data.m_order &&
this->getDefaultMode() == data.getDefaultMode() &&
m_defaultValue == data.m_defaultValue;
}
}

5
src/opm/parser/eclipse/EclipseState/Tables/PolyInjTables.cpp
View File

@ -258,11 +258,6 @@ namespace Opm{
return m_ref_polymer_concentration;
}
void SkprpolyTable::setReferenceConcentration(double refConcentration)
{
m_ref_polymer_concentration = refConcentration;
}
const std::vector<std::vector<double>>&
SkprpolyTable::getSkinPressures() const
{

37
src/opm/parser/eclipse/EclipseState/Tables/PvtxTable.cpp
View File

@ -165,37 +165,12 @@ namespace Opm {
}
const ColumnSchema& PvtxTable::getOuterColumnSchema() const {
return m_outerColumnSchema;
}
const TableColumn& PvtxTable::getOuterColumn() const {
return m_outerColumn;
}
const TableSchema& PvtxTable::getUnderSaturatedSchema() const {
return m_underSaturatedSchema;
}
const TableSchema& PvtxTable::getSaturatedSchema() const {
return m_saturatedSchema;
}
const std::vector<SimpleTable>& PvtxTable::getUnderSaturatedTables() const {
return m_underSaturatedTables;
}
bool PvtxTable::operator==(const PvtxTable& data) const {
return this->getOuterColumnSchema() == data.getOuterColumnSchema() &&
this->getOuterColumn() == data.getOuterColumn() &&
this->getUnderSaturatedSchema() == data.getUnderSaturatedSchema() &&
this->getSaturatedSchema() == data.getSaturatedSchema() &&
this->getUnderSaturatedTables() == data.getUnderSaturatedTables() &&
this->getSaturatedTable() == data.getSaturatedTable();
return this->m_outerColumnSchema == data.m_outerColumnSchema &&
this->m_outerColumn == data.m_outerColumn &&
this->m_underSaturatedSchema == data.m_underSaturatedSchema &&
this->m_saturatedSchema == data.m_saturatedSchema &&
this->m_underSaturatedTables == data.m_underSaturatedTables &&
this->m_saturatedTable == data.m_saturatedTable;
}
}

4
src/opm/parser/eclipse/EclipseState/Tables/Rock2dTable.cpp
View File

@ -64,8 +64,8 @@ namespace Opm {
bool Rock2dTable::operator==(const Rock2dTable& data) const
{
return this->pvmultValues() == data.pvmultValues() &&
this->pressureValues() == data.pressureValues();
return this->m_pvmultValues == data.m_pvmultValues &&
this->m_pressureValues == data.m_pressureValues;
}
}

4
src/opm/parser/eclipse/EclipseState/Tables/Rock2dtrTable.cpp
View File

@ -64,8 +64,8 @@ namespace Opm {
bool Rock2dtrTable::operator==(const Rock2dtrTable& data) const
{
return this->transMultValues() == data.transMultValues() &&
this->pressureValues() == data.pressureValues();
return this->m_transMultValues == data.m_transMultValues &&
this->m_pressureValues == data.m_pressureValues;
}
}

20
src/opm/parser/eclipse/EclipseState/Tables/SimpleTable.cpp
View File

@ -51,20 +51,6 @@ namespace Opm {
}
const TableSchema& SimpleTable::schema() const {
return m_schema;
}
const OrderedMap<std::string, TableColumn>& SimpleTable::columns() const {
return m_columns;
}
bool SimpleTable::jfunc() const {
return m_jfunc;
}
void SimpleTable::addRow( const std::vector<double>& row) {
if (row.size() == numColumns()) {
for (size_t colIndex = 0; colIndex < numColumns(); colIndex++) {
@ -184,8 +170,8 @@ namespace Opm {
bool SimpleTable::operator==(const SimpleTable& data) const {
return this->schema() == data.schema() &&
this->columns() == data.columns() &&
this->jfunc() == data.jfunc();
return this->m_schema == data.m_schema &&
this->m_columns == data.m_columns &&
this->m_jfunc == data.m_jfunc;
}
}

24
src/opm/parser/eclipse/EclipseState/Tables/TableColumn.cpp
View File

@ -62,26 +62,10 @@ namespace Opm {
throw std::invalid_argument("Incorrect ordering of values in column: " + m_schema.name());
}
const ColumnSchema& TableColumn::schema() const {
return m_schema;
}
const std::string& TableColumn::name() const {
return m_name;
}
const std::vector<double>& TableColumn::values() const {
return m_values;
}
const std::vector<bool>& TableColumn::defaults() const {
return m_default;
}
size_t TableColumn::defaultCount() const {
return m_defaultCount;
}
void TableColumn::assertNext(size_t index , double value) const {
size_t nextIndex = index + 1;
if (nextIndex < m_values.size()) {
@ -359,11 +343,11 @@ namespace Opm {
}
bool TableColumn::operator==(const TableColumn& data) const {
return this->schema() == data.schema() &&
return this->m_schema == data.m_schema &&
this->name() == data.name() &&
this->values() == data.values() &&
this->defaults() == data.defaults() &&
this->defaultCount() == data.defaultCount();
this->m_values == data.m_values &&
this->m_default == data.m_default &&
this->m_defaultCount == data.m_defaultCount;
}
}

29
src/opm/parser/eclipse/EclipseState/Tables/TableManager.cpp
View File

@ -1194,6 +1194,35 @@ namespace Opm {
solventtables[lineIdx].init(keyword.getRecord(lineIdx));
}
}
TableManager::SplitSimpleTables TableManager::splitSimpleTable(std::map<std::string,TableContainer>& simpleTables)
{
SplitSimpleTables result;
// PlyshlogTable need special treatment
auto it = simpleTables.find("PLYSHLOG");
if (it != simpleTables.end()) {
result.plyshMax = it->second.max();
for (const auto& mapIt : it->second.tables()) {
auto ptr = std::static_pointer_cast<PlyshlogTable>(mapIt.second);
result.plyshMap.insert(std::make_pair(mapIt.first, ptr));
}
simpleTables.erase(it);
}
// RocktabTable need special treatment
it = simpleTables.find("ROCKMAP");
if (it != simpleTables.end()) {
result.rockMax = it->second.max();
for (const auto& mapIt : it->second.tables()) {
auto ptr = std::static_pointer_cast<RocktabTable>(mapIt.second);
result.rockMap.insert(std::make_pair(mapIt.first, ptr));
}
simpleTables.erase(it);
}
return result;
}
}

6
src/opm/parser/eclipse/EclipseState/Tables/TableSchema.cpp
View File

@ -47,11 +47,7 @@ namespace Opm {
return m_columns.count( name ) > 0;
}
const OrderedMap<std::string, ColumnSchema>& TableSchema::getColumns() const {
return m_columns;
}
bool TableSchema::operator==(const TableSchema& data) const {
return this->getColumns() == data.getColumns();
return this->m_columns == data.m_columns;
}
}

4
src/opm/parser/eclipse/EclipseState/Tables/Tables.cpp
View File

@ -875,10 +875,6 @@ const TableColumn& RocktabTable::getTransmissibilityMultiplierZColumn() const {
return SimpleTable::getColumn(4);
}
bool RocktabTable::isDirectional() const {
return m_isDirectional;
}
bool RocktabTable::operator==(const RocktabTable& data) const {
return this->SimpleTable::operator==(data) &&
m_isDirectional == data.m_isDirectional;