21aaceaed9
There has never really been a natural home for initial properties that aren't InitConfig, meaning information such as phases in the deck and other runspec information hasn't had a natural home. This patch introduces the Runspec object on EclipseState for phase information and other similar properties that are interesting and static for when setting up parameters etc. for simulation, that aren't all that interesting once simulation starts. An additional benefit is a leaner implementation for the phase enum and some stricter semantics via enum classes.
707 lines
28 KiB
C++
707 lines
28 KiB
C++
/*
|
|
Copyright 2015 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/>.
|
|
*/
|
|
|
|
#include <opm/parser/eclipse/Parser/ParserKeywords/E.hpp>
|
|
#include <opm/parser/eclipse/Parser/ParserKeywords/M.hpp>
|
|
#include <opm/parser/eclipse/Parser/ParserKeywords/V.hpp>
|
|
#include <opm/parser/eclipse/Parser/ParserKeywords/T.hpp>
|
|
#include <opm/parser/eclipse/Deck/Deck.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/TableManager.hpp>
|
|
#include <opm/parser/eclipse/Parser/ParserKeywords/E.hpp>
|
|
#include <opm/parser/eclipse/Parser/ParserKeywords/M.hpp>
|
|
#include <opm/parser/eclipse/Parser/ParserKeywords/P.hpp>
|
|
#include <opm/parser/eclipse/Parser/ParserKeywords/T.hpp>
|
|
#include <opm/parser/eclipse/Parser/ParserKeywords/V.hpp>
|
|
|
|
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp> // Phase::PhaseEnum
|
|
#include <opm/parser/eclipse/EclipseState/Tables/EnkrvdTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/EnptvdTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/GasvisctTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/ImkrvdTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/ImptvdTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/MiscTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/MsfnTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/OilvisctTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/PlyadsTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/PlydhflfTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/PlymaxTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/PlyrockTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/PlyshlogTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/PlyviscTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/PmiscTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/TlpmixpaTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/PvdgTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/PvdoTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/PvdsTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/RocktabTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/RsvdTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/RtempvdTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/RvvdTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/SgcwmisTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/SgfnTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/SgofTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/SgwfnTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/SlgofTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/Sof2Table.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/Sof3Table.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/SorwmisTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/SsfnTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/SwfnTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/SwofTable.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/TableContainer.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/WatvisctTable.hpp>
|
|
|
|
#include <opm/parser/eclipse/EclipseState/Tables/Tabdims.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/Eqldims.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Tables/Regdims.hpp>
|
|
|
|
namespace Opm {
|
|
|
|
TableManager::TableManager( const Deck& deck )
|
|
:
|
|
hasImptvd (deck.hasKeyword("IMPTVD")),
|
|
hasEnptvd (deck.hasKeyword("ENPTVD")),
|
|
hasEqlnum (deck.hasKeyword("EQLNUM"))
|
|
{
|
|
initDims( deck );
|
|
initSimpleTables( deck );
|
|
initFullTables(deck, "PVTG", m_pvtgTables);
|
|
initFullTables(deck, "PVTO", m_pvtoTables);
|
|
|
|
initVFPProdTables(deck, m_vfpprodTables);
|
|
initVFPInjTables(deck, m_vfpinjTables);
|
|
}
|
|
|
|
void TableManager::initDims(const Deck& deck) {
|
|
using namespace Opm::ParserKeywords;
|
|
if (deck.hasKeyword<TABDIMS>()) {
|
|
const auto& keyword = deck.getKeyword<TABDIMS>();
|
|
const auto& record = keyword.getRecord(0);
|
|
int ntsfun = record.getItem<TABDIMS::NTSFUN>().get< int >(0);
|
|
int ntpvt = record.getItem<TABDIMS::NTPVT>().get< int >(0);
|
|
int nssfun = record.getItem<TABDIMS::NSSFUN>().get< int >(0);
|
|
int nppvt = record.getItem<TABDIMS::NPPVT>().get< int >(0);
|
|
int ntfip = record.getItem<TABDIMS::NTFIP>().get< int >(0);
|
|
int nrpvt = record.getItem<TABDIMS::NRPVT>().get< int >(0);
|
|
|
|
m_tabdims = std::make_shared<Tabdims>(ntsfun , ntpvt , nssfun , nppvt , ntfip , nrpvt);
|
|
} else
|
|
m_tabdims = std::make_shared<Tabdims>();
|
|
|
|
if (deck.hasKeyword<EQLDIMS>()) {
|
|
const auto& keyword = deck.getKeyword<EQLDIMS>();
|
|
const auto& record = keyword.getRecord(0);
|
|
int ntsequl = record.getItem<EQLDIMS::NTEQUL>().get< int >(0);
|
|
int nodes_p = record.getItem<EQLDIMS::DEPTH_NODES_P>().get< int >(0);
|
|
int nodes_tab = record.getItem<EQLDIMS::DEPTH_NODES_TAB>().get< int >(0);
|
|
int nttrvd = record.getItem<EQLDIMS::NTTRVD>().get< int >(0);
|
|
int ntsrvd = record.getItem<EQLDIMS::NSTRVD>().get< int >(0);
|
|
|
|
m_eqldims = std::make_shared<Eqldims>(ntsequl , nodes_p , nodes_tab , nttrvd , ntsrvd );
|
|
} else
|
|
m_eqldims = std::make_shared<Eqldims>();
|
|
|
|
if (deck.hasKeyword<REGDIMS>()) {
|
|
const auto& keyword = deck.getKeyword<REGDIMS>();
|
|
const auto& record = keyword.getRecord(0);
|
|
int ntfip = record.getItem<REGDIMS::NTFIP>().get< int >(0);
|
|
int nmfipr = record.getItem<REGDIMS::NMFIPR>().get< int >(0);
|
|
int nrfreg = record.getItem<REGDIMS::NRFREG>().get< int >(0);
|
|
int ntfreg = record.getItem<REGDIMS::NTFREG>().get< int >(0);
|
|
int nplmix = record.getItem<REGDIMS::NPLMIX>().get< int >(0);
|
|
m_regdims = std::make_shared<Regdims>( ntfip , nmfipr , nrfreg , ntfreg , nplmix );
|
|
} else
|
|
m_regdims = std::make_shared<Regdims>();
|
|
}
|
|
|
|
|
|
void TableManager::addTables( const std::string& tableName , size_t numTables) {
|
|
m_simpleTables.emplace(std::make_pair(tableName , TableContainer( numTables )));
|
|
}
|
|
|
|
|
|
bool TableManager::hasTables( const std::string& tableName ) const {
|
|
auto pair = m_simpleTables.find( tableName );
|
|
if (pair == m_simpleTables.end())
|
|
return false;
|
|
else {
|
|
const auto& tables = pair->second;
|
|
return !tables.empty();
|
|
}
|
|
}
|
|
|
|
|
|
const TableContainer& TableManager::getTables( const std::string& tableName ) const {
|
|
auto pair = m_simpleTables.find( tableName );
|
|
if (pair == m_simpleTables.end())
|
|
throw std::invalid_argument("No such table collection: " + tableName);
|
|
else
|
|
return pair->second;
|
|
}
|
|
|
|
TableContainer& TableManager::forceGetTables( const std::string& tableName , size_t numTables ) {
|
|
auto pair = m_simpleTables.find( tableName );
|
|
if (pair == m_simpleTables.end()) {
|
|
addTables( tableName , numTables );
|
|
pair = m_simpleTables.find( tableName );
|
|
}
|
|
return pair->second;
|
|
}
|
|
|
|
|
|
const TableContainer& TableManager::operator[](const std::string& tableName) const {
|
|
return getTables(tableName);
|
|
}
|
|
|
|
void TableManager::initSimpleTables(const Deck& deck) {
|
|
addTables( "SWOF" , m_tabdims->getNumSatTables() );
|
|
addTables( "SGWFN", m_tabdims->getNumSatTables() );
|
|
addTables( "SGOF", m_tabdims->getNumSatTables() );
|
|
addTables( "SLGOF", m_tabdims->getNumSatTables() );
|
|
addTables( "SOF2", m_tabdims->getNumSatTables() );
|
|
addTables( "SOF3", m_tabdims->getNumSatTables() );
|
|
addTables( "SWFN", m_tabdims->getNumSatTables() );
|
|
addTables( "SGFN", m_tabdims->getNumSatTables() );
|
|
addTables( "SSFN", m_tabdims->getNumSatTables() );
|
|
addTables( "MSFN", m_tabdims->getNumSatTables() );
|
|
|
|
addTables( "PLYADS", m_tabdims->getNumSatTables() );
|
|
addTables( "PLYROCK", m_tabdims->getNumSatTables());
|
|
addTables( "PLYVISC", m_tabdims->getNumPVTTables());
|
|
addTables( "PLYDHFLF", m_tabdims->getNumPVTTables());
|
|
|
|
addTables( "PVDG", m_tabdims->getNumPVTTables());
|
|
addTables( "PVDO", m_tabdims->getNumPVTTables());
|
|
addTables( "PVDS", m_tabdims->getNumPVTTables());
|
|
|
|
addTables( "OILVISCT", m_tabdims->getNumPVTTables());
|
|
addTables( "WATVISCT", m_tabdims->getNumPVTTables());
|
|
addTables( "GASVISCT", m_tabdims->getNumPVTTables());
|
|
|
|
addTables( "PLYMAX", m_regdims->getNPLMIX());
|
|
addTables( "RSVD", m_eqldims->getNumEquilRegions());
|
|
addTables( "RVVD", m_eqldims->getNumEquilRegions());
|
|
|
|
{
|
|
size_t numMiscibleTables = ParserKeywords::MISCIBLE::NTMISC::defaultValue;
|
|
if (deck.hasKeyword<ParserKeywords::MISCIBLE>()) {
|
|
const auto& keyword = deck.getKeyword<ParserKeywords::MISCIBLE>();
|
|
const auto& record = keyword.getRecord(0);
|
|
numMiscibleTables = static_cast<size_t>(record.getItem<ParserKeywords::MISCIBLE::NTMISC>().get< int >(0));
|
|
}
|
|
addTables( "SORWMIS", numMiscibleTables);
|
|
addTables( "SGCWMIS", numMiscibleTables);
|
|
addTables( "MISC", numMiscibleTables);
|
|
addTables( "PMISC", numMiscibleTables);
|
|
addTables( "TLPMIXPA", numMiscibleTables);
|
|
}
|
|
|
|
{
|
|
size_t numEndScaleTables = ParserKeywords::ENDSCALE::NUM_TABLES::defaultValue;
|
|
|
|
if (deck.hasKeyword<ParserKeywords::ENDSCALE>()) {
|
|
const auto& keyword = deck.getKeyword<ParserKeywords::ENDSCALE>();
|
|
const auto& record = keyword.getRecord(0);
|
|
numEndScaleTables = static_cast<size_t>(record.getItem<ParserKeywords::ENDSCALE::NUM_TABLES>().get< int >(0));
|
|
}
|
|
|
|
addTables( "ENKRVD", numEndScaleTables);
|
|
addTables( "ENPTVD", numEndScaleTables);
|
|
addTables( "IMKRVD", numEndScaleTables);
|
|
addTables( "IMPTVD", numEndScaleTables);
|
|
}
|
|
{
|
|
size_t numRocktabTables = ParserKeywords::ROCKCOMP::NTROCC::defaultValue;
|
|
|
|
if (deck.hasKeyword<ParserKeywords::ROCKCOMP>()) {
|
|
const auto& keyword = deck.getKeyword<ParserKeywords::ROCKCOMP>();
|
|
const auto& record = keyword.getRecord(0);
|
|
numRocktabTables = static_cast<size_t>(record.getItem<ParserKeywords::ROCKCOMP::NTROCC>().get< int >(0));
|
|
}
|
|
addTables( "ROCKTAB", numRocktabTables);
|
|
}
|
|
|
|
initSimpleTableContainer<SwofTable>(deck, "SWOF" , m_tabdims->getNumSatTables());
|
|
initSimpleTableContainer<SgwfnTable>(deck, "SGWFN", m_tabdims->getNumSatTables());
|
|
initSimpleTableContainer<SgofTable>(deck, "SGOF" , m_tabdims->getNumSatTables());
|
|
initSimpleTableContainer<SlgofTable>(deck, "SLGOF" , m_tabdims->getNumSatTables());
|
|
initSimpleTableContainer<Sof2Table>(deck, "SOF2" , m_tabdims->getNumSatTables());
|
|
initSimpleTableContainer<Sof3Table>(deck, "SOF3" , m_tabdims->getNumSatTables());
|
|
initSimpleTableContainer<SwfnTable>(deck, "SWFN" , m_tabdims->getNumSatTables());
|
|
initSimpleTableContainer<SgfnTable>(deck, "SGFN" , m_tabdims->getNumSatTables());
|
|
initSimpleTableContainer<SsfnTable>(deck, "SSFN" , m_tabdims->getNumSatTables());
|
|
initSimpleTableContainer<MsfnTable>(deck, "MSFN" , m_tabdims->getNumSatTables());
|
|
|
|
|
|
initSimpleTableContainer<RsvdTable>(deck, "RSVD" , m_eqldims->getNumEquilRegions());
|
|
initSimpleTableContainer<RvvdTable>(deck, "RVVD" , m_eqldims->getNumEquilRegions());
|
|
{
|
|
size_t numEndScaleTables = ParserKeywords::ENDSCALE::NUM_TABLES::defaultValue;
|
|
|
|
if (deck.hasKeyword<ParserKeywords::ENDSCALE>()) {
|
|
const auto& keyword = deck.getKeyword<ParserKeywords::ENDSCALE>();
|
|
const auto& record = keyword.getRecord(0);
|
|
numEndScaleTables = static_cast<size_t>(record.getItem<ParserKeywords::ENDSCALE::NUM_TABLES>().get< int >(0));
|
|
}
|
|
|
|
initSimpleTableContainer<EnkrvdTable>( deck , "ENKRVD", numEndScaleTables);
|
|
initSimpleTableContainer<EnptvdTable>( deck , "ENPTVD", numEndScaleTables);
|
|
initSimpleTableContainer<ImkrvdTable>( deck , "IMKRVD", numEndScaleTables);
|
|
initSimpleTableContainer<ImptvdTable>( deck , "IMPTVD", numEndScaleTables);
|
|
}
|
|
|
|
{
|
|
size_t numMiscibleTables = ParserKeywords::MISCIBLE::NTMISC::defaultValue;
|
|
if (deck.hasKeyword<ParserKeywords::MISCIBLE>()) {
|
|
const auto& keyword = deck.getKeyword<ParserKeywords::MISCIBLE>();
|
|
const auto& record = keyword.getRecord(0);
|
|
numMiscibleTables = static_cast<size_t>(record.getItem<ParserKeywords::MISCIBLE::NTMISC>().get< int >(0));
|
|
}
|
|
initSimpleTableContainer<SorwmisTable>(deck, "SORWMIS", numMiscibleTables);
|
|
initSimpleTableContainer<SgcwmisTable>(deck, "SGCWMIS", numMiscibleTables);
|
|
initSimpleTableContainer<MiscTable>(deck, "MISC", numMiscibleTables);
|
|
initSimpleTableContainer<PmiscTable>(deck, "PMISC", numMiscibleTables);
|
|
initSimpleTableContainer<TlpmixpaTable>(deck, "TLPMIXPA", numMiscibleTables);
|
|
|
|
}
|
|
|
|
initSimpleTableContainer<PvdgTable>(deck, "PVDG", m_tabdims->getNumPVTTables());
|
|
initSimpleTableContainer<PvdoTable>(deck, "PVDO", m_tabdims->getNumPVTTables());
|
|
initSimpleTableContainer<PvdsTable>(deck, "PVDS", m_tabdims->getNumPVTTables());
|
|
initSimpleTableContainer<OilvisctTable>(deck, "OILVISCT", m_tabdims->getNumPVTTables());
|
|
initSimpleTableContainer<WatvisctTable>(deck, "WATVISCT", m_tabdims->getNumPVTTables());
|
|
|
|
initSimpleTableContainer<PlyadsTable>(deck, "PLYADS", m_tabdims->getNumSatTables());
|
|
initSimpleTableContainer<PlyviscTable>(deck, "PLYVISC", m_tabdims->getNumPVTTables());
|
|
initSimpleTableContainer<PlydhflfTable>(deck, "PLYDHFLF", m_tabdims->getNumPVTTables());
|
|
initPlyrockTables(deck);
|
|
initPlymaxTables(deck);
|
|
initGasvisctTables(deck);
|
|
initRTempTables(deck);
|
|
initRocktabTables(deck);
|
|
initPlyshlogTables(deck);
|
|
}
|
|
|
|
|
|
void TableManager::initRTempTables(const Deck& deck) {
|
|
// the temperature vs depth table. the problem here is that
|
|
// the TEMPVD (E300) and RTEMPVD (E300 + E100) keywords are
|
|
// synonymous, but we want to provide only a single cannonical
|
|
// API here, so we jump through some small hoops...
|
|
if (deck.hasKeyword("TEMPVD") && deck.hasKeyword("RTEMPVD"))
|
|
throw std::invalid_argument("The TEMPVD and RTEMPVD tables are mutually exclusive!");
|
|
else if (deck.hasKeyword("TEMPVD"))
|
|
initSimpleTableContainer<RtempvdTable>(deck, "TEMPVD", "RTEMPVD", m_eqldims->getNumEquilRegions());
|
|
else if (deck.hasKeyword("RTEMPVD"))
|
|
initSimpleTableContainer<RtempvdTable>(deck, "RTEMPVD", "RTEMPVD" , m_eqldims->getNumEquilRegions());
|
|
}
|
|
|
|
|
|
void TableManager::initGasvisctTables(const Deck& deck) {
|
|
|
|
const std::string keywordName = "GASVISCT";
|
|
size_t numTables = m_tabdims->getNumPVTTables();
|
|
|
|
if (!deck.hasKeyword(keywordName))
|
|
return; // the table is not featured by the deck...
|
|
|
|
auto& container = forceGetTables(keywordName , numTables);
|
|
|
|
if (deck.count(keywordName) > 1) {
|
|
complainAboutAmbiguousKeyword(deck, keywordName);
|
|
return;
|
|
}
|
|
|
|
const auto& tableKeyword = deck.getKeyword(keywordName);
|
|
for (size_t tableIdx = 0; tableIdx < tableKeyword.size(); ++tableIdx) {
|
|
const auto& tableRecord = tableKeyword.getRecord( tableIdx );
|
|
const auto& dataItem = tableRecord.getItem( 0 );
|
|
if (dataItem.size() > 0) {
|
|
std::shared_ptr<GasvisctTable> table = std::make_shared<GasvisctTable>( deck , dataItem );
|
|
container.addTable( tableIdx , table );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void TableManager::initPlyshlogTables(const Deck& deck) {
|
|
const std::string keywordName = "PLYSHLOG";
|
|
|
|
if (!deck.hasKeyword(keywordName)) {
|
|
return;
|
|
}
|
|
|
|
if (!deck.count(keywordName)) {
|
|
complainAboutAmbiguousKeyword(deck, keywordName);
|
|
return;
|
|
}
|
|
size_t numTables = m_tabdims->getNumPVTTables();
|
|
auto& container = forceGetTables(keywordName , numTables);
|
|
const auto& tableKeyword = deck.getKeyword(keywordName);
|
|
|
|
if (tableKeyword.size() > 2) {
|
|
std::string msg = "The Parser does currently NOT support the alternating record schema used in PLYSHLOG";
|
|
throw std::invalid_argument( msg );
|
|
}
|
|
|
|
for (size_t tableIdx = 0; tableIdx < tableKeyword.size(); tableIdx += 2) {
|
|
const auto& indexRecord = tableKeyword.getRecord( tableIdx );
|
|
const auto& dataRecord = tableKeyword.getRecord( tableIdx + 1);
|
|
const auto& dataItem = dataRecord.getItem( 0 );
|
|
if (dataItem.size() > 0) {
|
|
std::shared_ptr<PlyshlogTable> table = std::make_shared<PlyshlogTable>(indexRecord , dataRecord);
|
|
container.addTable( tableIdx , table );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void TableManager::initPlyrockTables(const Deck& deck) {
|
|
size_t numTables = m_tabdims->getNumSatTables();
|
|
const std::string keywordName = "PLYROCK";
|
|
if (!deck.hasKeyword(keywordName)) {
|
|
return;
|
|
}
|
|
|
|
if (!deck.count(keywordName)) {
|
|
complainAboutAmbiguousKeyword(deck, keywordName);
|
|
return;
|
|
}
|
|
|
|
const auto& keyword = deck.getKeyword<ParserKeywords::PLYROCK>();
|
|
auto& container = forceGetTables(keywordName , numTables);
|
|
for (size_t tableIdx = 0; tableIdx < keyword.size(); ++tableIdx) {
|
|
const auto& tableRecord = keyword.getRecord( tableIdx );
|
|
std::shared_ptr<PlyrockTable> table = std::make_shared<PlyrockTable>(tableRecord);
|
|
container.addTable( tableIdx , table );
|
|
}
|
|
}
|
|
|
|
|
|
void TableManager::initPlymaxTables(const Deck& deck) {
|
|
size_t numTables = m_regdims->getNPLMIX();
|
|
const std::string keywordName = "PLYMAX";
|
|
if (!deck.hasKeyword(keywordName)) {
|
|
return;
|
|
}
|
|
|
|
if (!deck.count(keywordName)) {
|
|
complainAboutAmbiguousKeyword(deck, keywordName);
|
|
return;
|
|
}
|
|
|
|
const auto& keyword = deck.getKeyword<ParserKeywords::PLYMAX>();
|
|
auto& container = forceGetTables(keywordName , numTables);
|
|
for (size_t tableIdx = 0; tableIdx < keyword.size(); ++tableIdx) {
|
|
const auto& tableRecord = keyword.getRecord( tableIdx );
|
|
std::shared_ptr<PlymaxTable> table = std::make_shared<PlymaxTable>( tableRecord );
|
|
container.addTable( tableIdx , table );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void TableManager::initRocktabTables(const Deck& deck) {
|
|
if (!deck.hasKeyword("ROCKTAB"))
|
|
return; // ROCKTAB is not featured by the deck...
|
|
|
|
if (deck.count("ROCKTAB") > 1) {
|
|
complainAboutAmbiguousKeyword(deck, "ROCKTAB");
|
|
return;
|
|
}
|
|
const auto& rockcompKeyword = deck.getKeyword<ParserKeywords::ROCKCOMP>();
|
|
const auto& record = rockcompKeyword.getRecord( 0 );
|
|
size_t numTables = record.getItem<ParserKeywords::ROCKCOMP::NTROCC>().get< int >(0);
|
|
auto& container = forceGetTables("ROCKTAB" , numTables);
|
|
const auto rocktabKeyword = deck.getKeyword("ROCKTAB");
|
|
|
|
bool isDirectional = deck.hasKeyword<ParserKeywords::RKTRMDIR>();
|
|
bool useStressOption = false;
|
|
if (deck.hasKeyword<ParserKeywords::ROCKOPTS>()) {
|
|
const auto rockoptsKeyword = deck.getKeyword<ParserKeywords::ROCKOPTS>();
|
|
const auto& rockoptsRecord = rockoptsKeyword.getRecord(0);
|
|
const auto& item = rockoptsRecord.getItem<ParserKeywords::ROCKOPTS::METHOD>();
|
|
useStressOption = (item.getTrimmedString(0) == "STRESS");
|
|
}
|
|
|
|
for (size_t tableIdx = 0; tableIdx < rocktabKeyword.size(); ++tableIdx) {
|
|
const auto& tableRecord = rocktabKeyword.getRecord( tableIdx );
|
|
const auto& dataItem = tableRecord.getItem( 0 );
|
|
if (dataItem.size() > 0) {
|
|
std::shared_ptr<RocktabTable> table = std::make_shared<RocktabTable>( dataItem , isDirectional, useStressOption );
|
|
container.addTable( tableIdx , table );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void TableManager::initVFPProdTables(const Deck& deck,
|
|
std::map<int, VFPProdTable>& tableMap) {
|
|
if (!deck.hasKeyword(ParserKeywords::VFPPROD::keywordName)) {
|
|
return;
|
|
}
|
|
|
|
int num_tables = deck.count(ParserKeywords::VFPPROD::keywordName);
|
|
const auto& keywords = deck.getKeywordList<ParserKeywords::VFPPROD>();
|
|
const auto& unit_system = deck.getActiveUnitSystem();
|
|
for (int i=0; i<num_tables; ++i) {
|
|
const auto& keyword = *keywords[i];
|
|
|
|
VFPProdTable table;
|
|
table.init(keyword, unit_system);
|
|
m_messages.appendMessages(table.getMessageContainer());
|
|
|
|
//Check that the table in question has a unique ID
|
|
int table_id = table.getTableNum();
|
|
if (tableMap.find(table_id) == tableMap.end()) {
|
|
tableMap.insert(std::make_pair(table_id, std::move(table)));
|
|
}
|
|
else {
|
|
throw std::invalid_argument("Duplicate table numbers for VFPPROD found");
|
|
}
|
|
}
|
|
}
|
|
|
|
void TableManager::initVFPInjTables(const Deck& deck,
|
|
std::map<int, VFPInjTable>& tableMap) {
|
|
if (!deck.hasKeyword(ParserKeywords::VFPINJ::keywordName)) {
|
|
return;
|
|
}
|
|
|
|
int num_tables = deck.count(ParserKeywords::VFPINJ::keywordName);
|
|
const auto& keywords = deck.getKeywordList<ParserKeywords::VFPINJ>();
|
|
const auto& unit_system = deck.getActiveUnitSystem();
|
|
for (int i=0; i<num_tables; ++i) {
|
|
const auto& keyword = *keywords[i];
|
|
|
|
VFPInjTable table;
|
|
table.init(keyword, unit_system);
|
|
|
|
//Check that the table in question has a unique ID
|
|
int table_id = table.getTableNum();
|
|
if (tableMap.find(table_id) == tableMap.end()) {
|
|
tableMap.insert(std::make_pair(table_id, std::move(table)));
|
|
}
|
|
else {
|
|
throw std::invalid_argument("Duplicate table numbers for VFPINJ found");
|
|
}
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<const Tabdims> TableManager::getTabdims() const {
|
|
return m_tabdims;
|
|
}
|
|
|
|
|
|
/*
|
|
const std::vector<SwofTable>& TableManager::getSwofTables() const {
|
|
return m_swofTables;
|
|
}
|
|
*/
|
|
|
|
const TableContainer& TableManager::getSwofTables() const {
|
|
return getTables("SWOF");
|
|
}
|
|
|
|
const TableContainer& TableManager::getSgwfnTables() const {
|
|
return getTables("SGWFN");
|
|
}
|
|
|
|
const TableContainer& TableManager::getSlgofTables() const {
|
|
return getTables("SLGOF");
|
|
}
|
|
|
|
|
|
const TableContainer& TableManager::getSgofTables() const {
|
|
return getTables("SGOF");
|
|
}
|
|
|
|
const TableContainer& TableManager::getSof2Tables() const {
|
|
return getTables("SOF2");
|
|
}
|
|
|
|
const TableContainer& TableManager::getSof3Tables() const {
|
|
return getTables("SOF3");
|
|
}
|
|
|
|
const TableContainer& TableManager::getSwfnTables() const {
|
|
return getTables("SWFN");
|
|
}
|
|
|
|
const TableContainer& TableManager::getSgfnTables() const {
|
|
return getTables("SGFN");
|
|
}
|
|
|
|
const TableContainer& TableManager::getSsfnTables() const {
|
|
return getTables("SSFN");
|
|
}
|
|
|
|
const TableContainer& TableManager::getRsvdTables() const {
|
|
return getTables("RSVD");
|
|
}
|
|
|
|
const TableContainer& TableManager::getRvvdTables() const {
|
|
return getTables("RVVD");
|
|
}
|
|
|
|
const TableContainer& TableManager::getEnkrvdTables() const {
|
|
return getTables("ENKRVD");
|
|
}
|
|
|
|
const TableContainer& TableManager::getEnptvdTables() const {
|
|
return getTables("ENPTVD");
|
|
}
|
|
|
|
|
|
const TableContainer& TableManager::getImkrvdTables() const {
|
|
return getTables("IMKRVD");
|
|
}
|
|
|
|
const TableContainer& TableManager::getImptvdTables() const {
|
|
return getTables("IMPTVD");
|
|
}
|
|
|
|
const TableContainer& TableManager::getPvdgTables() const {
|
|
return getTables("PVDG");
|
|
}
|
|
|
|
const TableContainer& TableManager::getPvdoTables() const {
|
|
return getTables("PVDO");
|
|
}
|
|
|
|
const TableContainer& TableManager::getPvdsTables() const {
|
|
return getTables("PVDS");
|
|
}
|
|
|
|
const TableContainer& TableManager::getOilvisctTables() const {
|
|
return getTables("OILVISCT");
|
|
}
|
|
|
|
const TableContainer& TableManager::getWatvisctTables() const {
|
|
return getTables("WATVISCT");
|
|
}
|
|
|
|
const TableContainer& TableManager::getGasvisctTables() const {
|
|
return getTables("GASVISCT");
|
|
}
|
|
|
|
const TableContainer& TableManager::getRtempvdTables() const {
|
|
return getTables("RTEMPVD");
|
|
}
|
|
|
|
const TableContainer& TableManager::getRocktabTables() const {
|
|
return getTables("ROCKTAB");
|
|
}
|
|
|
|
|
|
const TableContainer& TableManager::getPlyadsTables() const {
|
|
return getTables("PLYADS");
|
|
}
|
|
|
|
const TableContainer& TableManager::getPlyviscTables() const {
|
|
return getTables("PLYVISC");
|
|
}
|
|
|
|
const TableContainer& TableManager::getPlydhflfTables() const {
|
|
return getTables("PLYDHFL");
|
|
}
|
|
|
|
const TableContainer& TableManager::getPlymaxTables() const {
|
|
return getTables("PLYMAX");
|
|
}
|
|
|
|
const TableContainer& TableManager::getPlyrockTables() const {
|
|
return getTables("PLYROCK");
|
|
}
|
|
|
|
const TableContainer& TableManager::getPlyshlogTables() const {
|
|
return getTables("PLYSHLOG");
|
|
}
|
|
|
|
const std::vector<PvtgTable>& TableManager::getPvtgTables() const {
|
|
return m_pvtgTables;
|
|
}
|
|
|
|
const std::vector<PvtoTable>& TableManager::getPvtoTables() const {
|
|
return m_pvtoTables;
|
|
}
|
|
|
|
const TableContainer& TableManager::getMsfnTables() const {
|
|
return getTables("MSFN");
|
|
}
|
|
const TableContainer& TableManager::getPmiscTables() const {
|
|
return getTables("PMISC");
|
|
}
|
|
const TableContainer& TableManager::getMiscTables() const {
|
|
return getTables("MISC");
|
|
}
|
|
const TableContainer& TableManager::getSgcwmisTables() const {
|
|
return getTables("SGCWMIS");
|
|
}
|
|
const TableContainer& TableManager::getSorwmisTables() const {
|
|
return getTables("SORWMIS");
|
|
}
|
|
const TableContainer& TableManager::getTlpmixpaTables() const {
|
|
return getTables("TLPMIXPA");
|
|
}
|
|
|
|
const std::map<int, VFPProdTable>& TableManager::getVFPProdTables() const {
|
|
return m_vfpprodTables;
|
|
}
|
|
|
|
const std::map<int, VFPInjTable>& TableManager::getVFPInjTables() const {
|
|
return m_vfpinjTables;
|
|
}
|
|
|
|
bool TableManager::useImptvd() const {
|
|
return hasImptvd;
|
|
}
|
|
|
|
bool TableManager::useEnptvd() const {
|
|
return hasEnptvd;
|
|
}
|
|
|
|
bool TableManager::useEqlnum() const {
|
|
return hasEqlnum;
|
|
}
|
|
|
|
|
|
const MessageContainer& TableManager::getMessageContainer() const {
|
|
return m_messages;
|
|
}
|
|
|
|
|
|
MessageContainer& TableManager::getMessageContainer() {
|
|
return m_messages;
|
|
}
|
|
|
|
|
|
void TableManager::complainAboutAmbiguousKeyword(const Deck& deck, const std::string& keywordName) {
|
|
m_messages.error("The " + keywordName + " keyword must be unique in the deck. Ignoring all!");
|
|
const auto& keywords = deck.getKeywordList(keywordName);
|
|
for (size_t i = 0; i < keywords.size(); ++i) {
|
|
std::string msg = "Ambiguous keyword "+keywordName+" defined here";
|
|
m_messages.error(keywords[i]->getFileName(), msg, keywords[i]->getLineNumber());
|
|
}
|
|
}
|
|
}
|
|
|
|
|