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

Changes in the log class:

Browse Source 
1. Moved to from eclipse/Parser -> eclipse/Log
 2. Renamed ParserLog -> OpmLog
This commit is contained in:
Joakim Hove 2014-12-12 20:56:34 +01:00
parent cf7e293635
commit b585655a5c
23 changed files with 383 additions and 362 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
opm/parser/eclipse/Applications/opm-eclkwtest.cpp
View File

@ -18,12 +18,13 @@
*/
#include <iostream>
#include <opm/parser/eclipse/Log/Logger.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Parser/ParserLog.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
static void printDeckDiagnostics(Opm::DeckConstPtr deck, Opm::ParserLogConstPtr parserLog, bool printAllKeywords) {
static void printDeckDiagnostics(Opm::DeckConstPtr deck, Opm::LoggerConstPtr logger, bool printAllKeywords) {
int recognizedKeywords = 0;
int unrecognizedKeywords = 0;
@ -38,11 +39,11 @@ static void printDeckDiagnostics(Opm::DeckConstPtr deck, Opm::ParserLogConstPtr
}
}
{
for (size_t iw = 0; iw < parserLog->size(); iw++) {
std::cout << parserLog->getFormattedMessage(iw) << "\n";
for (size_t iw = 0; iw < logger->size(); iw++) {
std::cout << logger->getFormattedMessage(iw) << "\n";
}
}
std::cout << "Total number of log messages: " << parserLog->size() << std::endl;
std::cout << "Total number of log messages: " << logger->size() << std::endl;
std::cout << "Number of recognized keywords: " << recognizedKeywords << std::endl;
std::cout << "Number of unrecognized keywords: " << unrecognizedKeywords << std::endl;
std::cout << "Total number of keywords: " << deck->size() << std::endl;
@ -66,10 +67,10 @@ int main(int argc, char** argv) {
Opm::ParserPtr parser(new Opm::Parser());
std::string file = argv[1];
Opm::ParserLogPtr parserLog(new Opm::ParserLog);
Opm::DeckConstPtr deck = parser->parseFile(file, parserLog);
Opm::LoggerPtr logger(new Opm::Logger);
Opm::DeckConstPtr deck = parser->parseFile(file, logger);
printDeckDiagnostics(deck, parserLog, printKeywords);
printDeckDiagnostics(deck, logger, printKeywords);
return 0;
}

10
opm/parser/eclipse/CMakeLists.txt
View File

@ -12,6 +12,9 @@ endif()
add_subdirectory( Applications )
set( log_source
Log/Logger.cpp )
set( rawdeck_source
RawDeck/StarToken.cpp
RawDeck/RawKeyword.cpp
@ -38,7 +41,6 @@ set( parser_source
Parser/ParserEnums.cpp
Parser/ParserKeyword.cpp
Parser/Parser.cpp
Parser/ParserLog.cpp
Parser/ParserRecord.cpp
Parser/ParserItem.cpp
Parser/ParserIntItem.cpp
@ -53,7 +55,6 @@ SET_SOURCE_FILES_PROPERTIES(${PROJECT_BINARY_DIR}/generated-source/DefaultKeywor
set( build_parser_source
Parser/ParserEnums.cpp
Parser/ParserKeyword.cpp
Parser/ParserLog.cpp
Parser/ParserRecord.cpp
Parser/ParserItem.cpp
Parser/ParserIntItem.cpp
@ -96,6 +97,8 @@ EclipseState/Grid/Fault.cpp
EclipseState/Grid/FaultCollection.cpp)
set( HEADER_FILES
Log/Logger.hpp
#
RawDeck/RawConsts.hpp
RawDeck/RawKeyword.hpp
RawDeck/RawRecord.hpp
@ -116,7 +119,6 @@ Deck/Section.hpp
Parser/ParserEnums.hpp
Parser/ParserKeyword.hpp
Parser/Parser.hpp
Parser/ParserLog.hpp
Parser/ParserRecord.hpp
Parser/ParserItem.hpp
Parser/ParserIntItem.hpp
@ -225,7 +227,7 @@ add_custom_target( keywordlist ALL COMMAND createDefaultKeywordList
#-----------------------------------------------------------------
add_library(Parser ${rawdeck_source} ${parser_source} ${deck_source} ${state_source} ${unit_source})
add_library(Parser ${rawdeck_source} ${parser_source} ${deck_source} ${state_source} ${unit_source} ${log_source})
add_dependencies(Parser keywordlist)
target_link_libraries(Parser opm-json ${Boost_LIBRARIES} ${ERT_LIBRARIES})

32
opm/parser/eclipse/Deck/Section.cpp
View File

@ -24,6 +24,8 @@
#include <set>
#include <string>
#include <opm/parser/eclipse/Log/Logger.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
@ -98,12 +100,12 @@ namespace Opm {
}
bool Section::checkSectionTopology(DeckConstPtr deck,
ParserLogPtr parserLog,
LoggerPtr logger,
bool ensureKeywordSectionAffiliation)
{
if (deck->size() == 0) {
std::string msg = "empty decks are invalid\n";
parserLog->addWarning("", -1, msg);
logger->addWarning("", -1, msg);
return false;
}
@ -111,7 +113,7 @@ namespace Opm {
if (deck->getKeyword(0)->name() != "RUNSPEC") {
std::string msg = "The first keyword of a valid deck must be RUNSPEC\n";
parserLog->addWarning(deck->getKeyword(0)->getFileName(),
logger->addWarning(deck->getKeyword(0)->getFileName(),
deck->getKeyword(0)->getLineNumber(),
msg);
deckValid = false;
@ -134,7 +136,7 @@ namespace Opm {
"The keyword '"+curKeywordName+"' is located in the '"+curSectionName
+"' section where it is invalid";
parserLog->addWarning(curKeyword->getFileName(),
logger->addWarning(curKeyword->getFileName(),
curKeyword->getLineNumber(),
msg);
deckValid = false;
@ -147,9 +149,9 @@ namespace Opm {
if (curKeywordName != "GRID") {
std::string msg =
"The RUNSPEC section must be followed by GRID instead of "+curKeywordName;
parserLog->addWarning(curKeyword->getFileName(),
curKeyword->getLineNumber(),
msg);
logger->addWarning(curKeyword->getFileName(),
curKeyword->getLineNumber(),
msg);
deckValid = false;
}
@ -159,7 +161,7 @@ namespace Opm {
if (curKeywordName != "EDIT" && curKeywordName != "PROPS") {
std::string msg =
"The GRID section must be followed by EDIT or PROPS instead of "+curKeywordName;
parserLog->addWarning(curKeyword->getFileName(),
logger->addWarning(curKeyword->getFileName(),
curKeyword->getLineNumber(),
msg);
deckValid = false;
@ -171,7 +173,7 @@ namespace Opm {
if (curKeywordName != "PROPS") {
std::string msg =
"The EDIT section must be followed by PROPS instead of "+curKeywordName;
parserLog->addWarning(curKeyword->getFileName(),
logger->addWarning(curKeyword->getFileName(),
curKeyword->getLineNumber(),
msg);
deckValid = false;
@ -183,7 +185,7 @@ namespace Opm {
if (curKeywordName != "REGIONS" && curKeywordName != "SOLUTION") {
std::string msg =
"The PROPS section must be followed by REGIONS or SOLUTION instead of "+curKeywordName;
parserLog->addWarning(curKeyword->getFileName(),
logger->addWarning(curKeyword->getFileName(),
curKeyword->getLineNumber(),
msg);
deckValid = false;
@ -195,7 +197,7 @@ namespace Opm {
if (curKeywordName != "SOLUTION") {
std::string msg =
"The REGIONS section must be followed by SOLUTION instead of "+curKeywordName;
parserLog->addWarning(curKeyword->getFileName(),
logger->addWarning(curKeyword->getFileName(),
curKeyword->getLineNumber(),
msg);
deckValid = false;
@ -207,7 +209,7 @@ namespace Opm {
if (curKeywordName != "SUMMARY" && curKeywordName != "SCHEDULE") {
std::string msg =
"The SOLUTION section must be followed by SUMMARY or SCHEDULE instead of "+curKeywordName;
parserLog->addWarning(curKeyword->getFileName(),
logger->addWarning(curKeyword->getFileName(),
curKeyword->getLineNumber(),
msg);
deckValid = false;
@ -219,7 +221,7 @@ namespace Opm {
if (curKeywordName != "SCHEDULE") {
std::string msg =
"The SUMMARY section must be followed by SCHEDULE instead of "+curKeywordName;
parserLog->addWarning(curKeyword->getFileName(),
logger->addWarning(curKeyword->getFileName(),
curKeyword->getLineNumber(),
msg);
deckValid = false;
@ -232,7 +234,7 @@ namespace Opm {
std::string msg =
"The SCHEDULE section must be the last one ("
+curKeywordName+" specified after SCHEDULE)";
parserLog->addWarning(curKeyword->getFileName(),
logger->addWarning(curKeyword->getFileName(),
curKeyword->getLineNumber(),
msg);
deckValid = false;
@ -244,7 +246,7 @@ namespace Opm {
const auto& curKeyword = deck->getKeyword(deck->size() - 1);
std::string msg =
"The last section of a valid deck must be SCHEDULE (is "+curSectionName+")";
parserLog->addWarning(curKeyword->getFileName(),
logger->addWarning(curKeyword->getFileName(),
curKeyword->getLineNumber(),
msg);
deckValid = false;

5
opm/parser/eclipse/Deck/Section.hpp
View File

@ -20,8 +20,9 @@
#ifndef SECTION_HPP
#define SECTION_HPP
#include <opm/parser/eclipse/Log/Logger.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Parser/ParserLog.hpp>
#include <boost/iterator/iterator_facade.hpp>
@ -55,7 +56,7 @@ namespace Opm {
// returns whether the deck has all mandatory sections and if all sections are in
// the right order
static bool checkSectionTopology(DeckConstPtr deck,
ParserLogPtr parserLog,
LoggerPtr logger,
bool ensureKeywordSectionAffiliation = false);
private:

46
opm/parser/eclipse/Deck/tests/DeckTests.cpp
View File

@ -21,8 +21,10 @@
#define BOOST_TEST_MODULE DeckTests
#include <stdexcept>
#include <boost/test/unit_test.hpp>
#include <opm/parser/eclipse/Parser/ParserLog.hpp>
#include <opm/parser/eclipse/Log/Logger.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
using namespace Opm;
@ -120,36 +122,36 @@ BOOST_AUTO_TEST_CASE(size_twokeyword_return2) {
BOOST_AUTO_TEST_CASE(DECKWARNING_EMPTYOK) {
ParserLog parserLog;
BOOST_CHECK_EQUAL(0U, parserLog.size());
Logger logger;
BOOST_CHECK_EQUAL(0U, logger.size());
}
BOOST_AUTO_TEST_CASE(DECKAddWarning) {
ParserLog parserLog;
parserLog.addNote("FILE", 100U, "NOTE");
BOOST_CHECK_EQUAL(1U, parserLog.size());
Logger logger;
logger.addNote("FILE", 100U, "NOTE");
BOOST_CHECK_EQUAL(1U, logger.size());
parserLog.addWarning("FILE2", 200U, "WARNING");
BOOST_CHECK_EQUAL(2U, parserLog.size());
logger.addWarning("FILE2", 200U, "WARNING");
BOOST_CHECK_EQUAL(2U, logger.size());
parserLog.addError("FILE3", 300U, "ERROR");
BOOST_CHECK_EQUAL(3U, parserLog.size());
logger.addError("FILE3", 300U, "ERROR");
BOOST_CHECK_EQUAL(3U, logger.size());
BOOST_CHECK_EQUAL(parserLog.getMessageType(0), ParserLog::Note);
BOOST_CHECK_EQUAL(parserLog.getDescription(0), "NOTE");
BOOST_CHECK_EQUAL(parserLog.getFileName(0), "FILE");
BOOST_CHECK_EQUAL(parserLog.getLineNumber(0), 100U);
BOOST_CHECK_EQUAL(logger.getMessageType(0), Logger::Note);
BOOST_CHECK_EQUAL(logger.getDescription(0), "NOTE");
BOOST_CHECK_EQUAL(logger.getFileName(0), "FILE");
BOOST_CHECK_EQUAL(logger.getLineNumber(0), 100U);
BOOST_CHECK_EQUAL(parserLog.getMessageType(1), ParserLog::Warning);
BOOST_CHECK_EQUAL(parserLog.getDescription(1), "WARNING");
BOOST_CHECK_EQUAL(parserLog.getFileName(1), "FILE2");
BOOST_CHECK_EQUAL(parserLog.getLineNumber(1), 200U);
BOOST_CHECK_EQUAL(logger.getMessageType(1), Logger::Warning);
BOOST_CHECK_EQUAL(logger.getDescription(1), "WARNING");
BOOST_CHECK_EQUAL(logger.getFileName(1), "FILE2");
BOOST_CHECK_EQUAL(logger.getLineNumber(1), 200U);
BOOST_CHECK_EQUAL(parserLog.getMessageType(2), ParserLog::Error);
BOOST_CHECK_EQUAL(parserLog.getDescription(2), "ERROR");
BOOST_CHECK_EQUAL(parserLog.getFileName(2), "FILE3");
BOOST_CHECK_EQUAL(parserLog.getLineNumber(2), 300U);
BOOST_CHECK_EQUAL(logger.getMessageType(2), Logger::Error);
BOOST_CHECK_EQUAL(logger.getDescription(2), "ERROR");
BOOST_CHECK_EQUAL(logger.getFileName(2), "FILE3");
BOOST_CHECK_EQUAL(logger.getLineNumber(2), 300U);
}

26
opm/parser/eclipse/Deck/tests/SectionTests.cpp
View File

@ -243,8 +243,8 @@ BOOST_AUTO_TEST_CASE(Section_ValidDecks) {
deck->addKeyword(std::make_shared<DeckKeyword>("SCHEDULE"));
deck->addKeyword(std::make_shared<DeckKeyword>("TEST5"));
ParserLogPtr parserLog(new ParserLog());
BOOST_CHECK(Opm::Section::checkSectionTopology(deck, parserLog));
LoggerPtr logger(new Logger());
BOOST_CHECK(Opm::Section::checkSectionTopology(deck, logger));
// deck with all optional sections
deck.reset(new Deck());
@ -272,7 +272,7 @@ BOOST_AUTO_TEST_CASE(Section_ValidDecks) {
deck->addKeyword(std::make_shared<DeckKeyword>("SCHEDULE"));
deck->addKeyword(std::make_shared<DeckKeyword>("TEST8"));
BOOST_CHECK(Opm::Section::checkSectionTopology(deck, parserLog));
BOOST_CHECK(Opm::Section::checkSectionTopology(deck, logger));
}
BOOST_AUTO_TEST_CASE(Section_InvalidDecks) {
@ -295,8 +295,8 @@ BOOST_AUTO_TEST_CASE(Section_InvalidDecks) {
deck->addKeyword(std::make_shared<DeckKeyword>("SCHEDULE"));
deck->addKeyword(std::make_shared<DeckKeyword>("TEST5"));
ParserLogPtr parserLog(new ParserLog());
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, parserLog));
LoggerPtr logger(new Logger());
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, logger));
// wrong section order
deck.reset(new Deck());
@ -324,7 +324,7 @@ BOOST_AUTO_TEST_CASE(Section_InvalidDecks) {
deck->addKeyword(std::make_shared<DeckKeyword>("SCHEDULE"));
deck->addKeyword(std::make_shared<DeckKeyword>("TEST8"));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, parserLog));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, logger));
// duplicate section
deck.reset(new Deck());
@ -355,7 +355,7 @@ BOOST_AUTO_TEST_CASE(Section_InvalidDecks) {
deck->addKeyword(std::make_shared<DeckKeyword>("SCHEDULE"));
deck->addKeyword(std::make_shared<DeckKeyword>("TEST8"));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, parserLog));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, logger));
// section after SCHEDULE
deck.reset(new Deck());
@ -383,7 +383,7 @@ BOOST_AUTO_TEST_CASE(Section_InvalidDecks) {
deck->addKeyword(std::make_shared<DeckKeyword>("EDIT"));
deck->addKeyword(std::make_shared<DeckKeyword>("TEST3"));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, parserLog));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, logger));
// missing RUNSPEC
deck.reset(new Deck());
@ -400,7 +400,7 @@ BOOST_AUTO_TEST_CASE(Section_InvalidDecks) {
deck->addKeyword(std::make_shared<DeckKeyword>("SCHEDULE"));
deck->addKeyword(std::make_shared<DeckKeyword>("TEST5"));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, parserLog));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, logger));
// missing GRID
deck.reset(new Deck());
@ -417,7 +417,7 @@ BOOST_AUTO_TEST_CASE(Section_InvalidDecks) {
deck->addKeyword(std::make_shared<DeckKeyword>("SCHEDULE"));
deck->addKeyword(std::make_shared<DeckKeyword>("TEST5"));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, parserLog));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, logger));
// missing PROPS
deck.reset(new Deck());
@ -434,7 +434,7 @@ BOOST_AUTO_TEST_CASE(Section_InvalidDecks) {
deck->addKeyword(std::make_shared<DeckKeyword>("SCHEDULE"));
deck->addKeyword(std::make_shared<DeckKeyword>("TEST5"));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, parserLog));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, logger));
// missing SOLUTION
deck.reset(new Deck());
@ -451,7 +451,7 @@ BOOST_AUTO_TEST_CASE(Section_InvalidDecks) {
deck->addKeyword(std::make_shared<DeckKeyword>("SCHEDULE"));
deck->addKeyword(std::make_shared<DeckKeyword>("TEST5"));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, parserLog));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, logger));
// missing SCHEDULE
deck.reset(new Deck());
@ -468,5 +468,5 @@ BOOST_AUTO_TEST_CASE(Section_InvalidDecks) {
deck->addKeyword(std::make_shared<DeckKeyword>("SOLUTION"));
deck->addKeyword(std::make_shared<DeckKeyword>("TEST4"));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, parserLog));
BOOST_CHECK(!Opm::Section::checkSectionTopology(deck, logger));
}

168
opm/parser/eclipse/EclipseState/EclipseState.cpp
View File

@ -17,16 +17,16 @@
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <opm/parser/eclipse/Log/Logger.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/Box.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/BoxManager.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.hpp>
#include <opm/parser/eclipse/Parser/ParserLog.hpp>
#include <iostream>
#include <sstream>
@ -110,21 +110,21 @@ namespace Opm {
}
EclipseState::EclipseState(DeckConstPtr deck, ParserLogPtr parserLog)
EclipseState::EclipseState(DeckConstPtr deck, LoggerPtr logger)
{
m_deckUnitSystem = deck->getActiveUnitSystem();
initPhases(deck, parserLog);
initTables(deck, parserLog);
initSchedule(deck, parserLog);
initTitle(deck, parserLog);
initPhases(deck, logger);
initTables(deck, logger);
initSchedule(deck, logger);
initTitle(deck, logger);
initEclipseGrid(deck, parserLog);
initEclipseGrid(deck, logger);
initProperties(deck, parserLog);
initTransMult(parserLog);
initFaults(deck, parserLog);
initMULTREGT(deck, parserLog);
initProperties(deck, logger);
initTransMult(logger);
initFaults(deck, logger);
initMULTREGT(deck, logger);
}
std::shared_ptr<const UnitSystem> EclipseState::getDeckUnitSystem() const {
@ -236,27 +236,27 @@ namespace Opm {
return m_title;
}
void EclipseState::initTables(DeckConstPtr deck, ParserLogPtr parserLog) {
initSimpleTables(deck, parserLog, "ENKRVD", m_enkrvdTables);
initSimpleTables(deck, parserLog, "ENPTVD", m_enptvdTables);
initSimpleTables(deck, parserLog, "IMKRVD", m_imkrvdTables);
initSimpleTables(deck, parserLog, "IMPTVD", m_imptvdTables);
initSimpleTables(deck, parserLog, "PLYADS", m_plyadsTables);
initSimpleTables(deck, parserLog, "PLYMAX", m_plymaxTables);
initSimpleTables(deck, parserLog, "PLYROCK", m_plyrockTables);
initSimpleTables(deck, parserLog, "PLYVISC", m_plyviscTables);
initSimpleTables(deck, parserLog, "PVDG", m_pvdgTables);
initSimpleTables(deck, parserLog, "PVDO", m_pvdoTables);
initSimpleTables(deck, parserLog, "RSVD", m_rsvdTables);
initSimpleTables(deck, parserLog, "RVVD", m_rvvdTables);
initSimpleTables(deck, parserLog, "SGOF", m_sgofTables);
initSimpleTables(deck, parserLog, "SOF2", m_sof2Tables);
initSimpleTables(deck, parserLog, "SWOF", m_swofTables);
initSimpleTables(deck, parserLog, "SWFN", m_swfnTables);
void EclipseState::initTables(DeckConstPtr deck, LoggerPtr logger) {
initSimpleTables(deck, logger, "ENKRVD", m_enkrvdTables);
initSimpleTables(deck, logger, "ENPTVD", m_enptvdTables);
initSimpleTables(deck, logger, "IMKRVD", m_imkrvdTables);
initSimpleTables(deck, logger, "IMPTVD", m_imptvdTables);
initSimpleTables(deck, logger, "PLYADS", m_plyadsTables);
initSimpleTables(deck, logger, "PLYMAX", m_plymaxTables);
initSimpleTables(deck, logger, "PLYROCK", m_plyrockTables);
initSimpleTables(deck, logger, "PLYVISC", m_plyviscTables);
initSimpleTables(deck, logger, "PVDG", m_pvdgTables);
initSimpleTables(deck, logger, "PVDO", m_pvdoTables);
initSimpleTables(deck, logger, "RSVD", m_rsvdTables);
initSimpleTables(deck, logger, "RVVD", m_rvvdTables);
initSimpleTables(deck, logger, "SGOF", m_sgofTables);
initSimpleTables(deck, logger, "SOF2", m_sof2Tables);
initSimpleTables(deck, logger, "SWOF", m_swofTables);
initSimpleTables(deck, logger, "SWFN", m_swfnTables);
// the ROCKTAB table comes with additional fun because the number of columns
//depends on the presence of the RKTRMDIR keyword...
initRocktabTables(deck, parserLog);
initRocktabTables(deck, logger);
// the temperature vs depth table. the problem here is that
// the TEMPVD (E300) and RTEMPVD (E300 + E100) keywords are
@ -265,19 +265,19 @@ namespace Opm {
if (deck->hasKeyword("TEMPVD") && deck->hasKeyword("RTEMPVD"))
throw std::invalid_argument("The TEMPVD and RTEMPVD tables are mutually exclusive!");
else if (deck->hasKeyword("TEMPVD"))
initSimpleTables(deck, parserLog, "TEMPVD", m_rtempvdTables);
initSimpleTables(deck, logger, "TEMPVD", m_rtempvdTables);
else if (deck->hasKeyword("RTEMPVD"))
initSimpleTables(deck, parserLog, "RTEMPVD", m_rtempvdTables);
initSimpleTables(deck, logger, "RTEMPVD", m_rtempvdTables);
initFullTables(deck, parserLog, "PVTG", m_pvtgTables);
initFullTables(deck, parserLog, "PVTO", m_pvtoTables);
initFullTables(deck, logger, "PVTG", m_pvtgTables);
initFullTables(deck, logger, "PVTO", m_pvtoTables);
}
void EclipseState::initSchedule(DeckConstPtr deck, ParserLogPtr parserLog) {
schedule = ScheduleConstPtr( new Schedule(deck, parserLog) );
void EclipseState::initSchedule(DeckConstPtr deck, LoggerPtr logger) {
schedule = ScheduleConstPtr( new Schedule(deck, logger) );
}
void EclipseState::initTransMult(ParserLogPtr /*parserLog*/) {
void EclipseState::initTransMult(LoggerPtr /*logger*/) {
EclipseGridConstPtr grid = getEclipseGrid();
m_transMult = std::make_shared<TransMult>( grid->getNX() , grid->getNY() , grid->getNZ());
@ -297,7 +297,7 @@ namespace Opm {
m_transMult->applyMULT(m_doubleGridProperties->getKeyword("MULTZ-"), FaceDir::ZMinus);
}
void EclipseState::initFaults(DeckConstPtr deck, ParserLogPtr parserLog) {
void EclipseState::initFaults(DeckConstPtr deck, LoggerPtr logger) {
EclipseGridConstPtr grid = getEclipseGrid();
m_faults = std::make_shared<FaultCollection>();
std::shared_ptr<Opm::GRIDSection> gridSection(new Opm::GRIDSection(deck) );
@ -331,11 +331,11 @@ namespace Opm {
}
}
setMULTFLT(gridSection, parserLog);
setMULTFLT(gridSection, logger);
if (Section::hasEDIT(deck)) {
std::shared_ptr<Opm::EDITSection> editSection(new Opm::EDITSection(deck) );
setMULTFLT(editSection, parserLog);
setMULTFLT(editSection, logger);
}
m_transMult->applyMULTFLT( m_faults );
@ -343,7 +343,7 @@ namespace Opm {
void EclipseState::setMULTFLT(std::shared_ptr<const Section> section, ParserLogPtr /*parserLog*/) const {
void EclipseState::setMULTFLT(std::shared_ptr<const Section> section, LoggerPtr /*logger*/) const {
for (size_t index=0; index < section->count("MULTFLT"); index++) {
DeckKeywordConstPtr faultsKeyword = section->getKeyword("MULTFLT" , index);
for (auto iter = faultsKeyword->begin(); iter != faultsKeyword->end(); ++iter) {
@ -358,7 +358,7 @@ namespace Opm {
void EclipseState::initMULTREGT(DeckConstPtr deck, ParserLogPtr /*parserLog*/) {
void EclipseState::initMULTREGT(DeckConstPtr deck, LoggerPtr /*logger*/) {
EclipseGridConstPtr grid = getEclipseGrid();
std::vector<Opm::DeckKeywordConstPtr> multregtKeywords;
@ -374,12 +374,12 @@ namespace Opm {
void EclipseState::initEclipseGrid(DeckConstPtr deck, ParserLogPtr parserLog) {
m_eclipseGrid = EclipseGridConstPtr( new EclipseGrid(deck, parserLog));
void EclipseState::initEclipseGrid(DeckConstPtr deck, LoggerPtr logger) {
m_eclipseGrid = EclipseGridConstPtr( new EclipseGrid(deck, logger));
}
void EclipseState::initPhases(DeckConstPtr deck, ParserLogPtr parserLog) {
void EclipseState::initPhases(DeckConstPtr deck, LoggerPtr logger) {
if (deck->hasKeyword("OIL"))
phases.insert(Phase::PhaseEnum::OIL);
@ -390,7 +390,7 @@ namespace Opm {
phases.insert(Phase::PhaseEnum::WATER);
if (phases.size() < 3)
parserLog->addNote("", -1, "Only " + std::to_string(static_cast<long long>(phases.size())) + " fluid phases are enabled");
logger->addNote("", -1, "Only " + std::to_string(static_cast<long long>(phases.size())) + " fluid phases are enabled");
}
@ -398,7 +398,7 @@ namespace Opm {
return (phases.count(phase) == 1);
}
void EclipseState::initTitle(DeckConstPtr deck, ParserLogPtr /*parserLog*/){
void EclipseState::initTitle(DeckConstPtr deck, LoggerPtr /*logger*/){
if (deck->hasKeyword("TITLE")) {
DeckKeywordConstPtr titleKeyword = deck->getKeyword("TITLE");
DeckRecordConstPtr record = titleKeyword->getRecord(0);
@ -408,12 +408,12 @@ namespace Opm {
}
}
void EclipseState::initRocktabTables(DeckConstPtr deck, ParserLogPtr parserLog) {
void EclipseState::initRocktabTables(DeckConstPtr deck, LoggerPtr logger) {
if (!deck->hasKeyword("ROCKTAB"))
return; // ROCKTAB is not featured by the deck...
if (deck->numKeywords("ROCKTAB") > 1) {
complainAboutAmbiguousKeyword(deck, parserLog, "ROCKTAB");
complainAboutAmbiguousKeyword(deck, logger, "ROCKTAB");
return;
}
@ -501,7 +501,7 @@ namespace Opm {
void EclipseState::loadGridPropertyFromDeckKeyword(std::shared_ptr<const Box> inputBox,
DeckKeywordConstPtr deckKeyword,
ParserLogPtr parserLog,
LoggerPtr logger,
int enabledTypes) {
const std::string& keyword = deckKeyword->name();
if (m_intGridProperties->supportsKeyword( keyword )) {
@ -515,14 +515,14 @@ namespace Opm {
gridProperty->loadFromDeckKeyword( inputBox , deckKeyword );
}
} else {
parserLog->addError(deckKeyword->getFileName(),
logger->addError(deckKeyword->getFileName(),
deckKeyword->getLineNumber(),
"Tried to load unsupported grid property from keyword: " + deckKeyword->name());
}
}
void EclipseState::initProperties(DeckConstPtr deck, ParserLogPtr parserLog) {
void EclipseState::initProperties(DeckConstPtr deck, LoggerPtr logger) {
typedef GridProperties<int>::SupportedKeywordInfo SupportedIntKeywordInfo;
std::shared_ptr<std::vector<SupportedIntKeywordInfo> > supportedIntKeywords(new std::vector<SupportedIntKeywordInfo>{
SupportedIntKeywordInfo( "SATNUM" , 1, "1" ),
@ -731,8 +731,8 @@ namespace Opm {
// process all integer grid properties before the double ones
// as these may be needed in order to initialize the double
// properties
processGridProperties(deck, parserLog, /*enabledTypes=*/IntProperties);
processGridProperties(deck, parserLog, /*enabledTypes=*/DoubleProperties);
processGridProperties(deck, logger, /*enabledTypes=*/IntProperties);
processGridProperties(deck, logger, /*enabledTypes=*/DoubleProperties);
}
double EclipseState::getSIScaling(const std::string &dimensionString) const
@ -740,62 +740,62 @@ namespace Opm {
return m_deckUnitSystem->getDimension(dimensionString)->getSIScaling();
}
void EclipseState::processGridProperties(Opm::DeckConstPtr deck, ParserLogPtr parserLog, int enabledTypes) {
void EclipseState::processGridProperties(Opm::DeckConstPtr deck, LoggerPtr logger, int enabledTypes) {
if (Section::hasGRID(deck)) {
std::shared_ptr<Opm::GRIDSection> gridSection(new Opm::GRIDSection(deck) );
scanSection(gridSection, parserLog, enabledTypes);
scanSection(gridSection, logger, enabledTypes);
}
if (Section::hasEDIT(deck)) {
std::shared_ptr<Opm::EDITSection> editSection(new Opm::EDITSection(deck) );
scanSection(editSection, parserLog, enabledTypes);
scanSection(editSection, logger, enabledTypes);
}
if (Section::hasPROPS(deck)) {
std::shared_ptr<Opm::PROPSSection> propsSection(new Opm::PROPSSection(deck) );
scanSection(propsSection, parserLog, enabledTypes);
scanSection(propsSection, logger, enabledTypes);
}
if (Section::hasREGIONS(deck)) {
std::shared_ptr<Opm::REGIONSSection> regionsSection(new Opm::REGIONSSection(deck) );
scanSection(regionsSection, parserLog, enabledTypes);
scanSection(regionsSection, logger, enabledTypes);
}
if (Section::hasSOLUTION(deck)) {
std::shared_ptr<Opm::SOLUTIONSection> solutionSection(new Opm::SOLUTIONSection(deck) );
scanSection(solutionSection, parserLog, enabledTypes);
scanSection(solutionSection, logger, enabledTypes);
}
}
void EclipseState::scanSection(std::shared_ptr<Opm::Section> section,
ParserLogPtr parserLog,
LoggerPtr logger,
int enabledTypes) {
BoxManager boxManager(m_eclipseGrid->getNX( ) , m_eclipseGrid->getNY() , m_eclipseGrid->getNZ());
for (auto iter = section->begin(); iter != section->end(); ++iter) {
DeckKeywordConstPtr deckKeyword = *iter;
if (supportsGridProperty(deckKeyword->name(), enabledTypes) )
loadGridPropertyFromDeckKeyword(boxManager.getActiveBox(), deckKeyword, parserLog, enabledTypes);
loadGridPropertyFromDeckKeyword(boxManager.getActiveBox(), deckKeyword, logger, enabledTypes);
else {
if (deckKeyword->name() == "ADD")
handleADDKeyword(deckKeyword, parserLog, boxManager, enabledTypes);
handleADDKeyword(deckKeyword, logger, boxManager, enabledTypes);
if (deckKeyword->name() == "BOX")
handleBOXKeyword(deckKeyword, parserLog, boxManager);
handleBOXKeyword(deckKeyword, logger, boxManager);
if (deckKeyword->name() == "COPY")
handleCOPYKeyword(deckKeyword, parserLog, boxManager, enabledTypes);
handleCOPYKeyword(deckKeyword, logger, boxManager, enabledTypes);
if (deckKeyword->name() == "EQUALS")
handleEQUALSKeyword(deckKeyword, parserLog, boxManager, enabledTypes);
handleEQUALSKeyword(deckKeyword, logger, boxManager, enabledTypes);
if (deckKeyword->name() == "ENDBOX")
handleENDBOXKeyword(boxManager);
if (deckKeyword->name() == "MULTIPLY")
handleMULTIPLYKeyword(deckKeyword, parserLog, boxManager, enabledTypes);
handleMULTIPLYKeyword(deckKeyword, logger, boxManager, enabledTypes);
boxManager.endKeyword();
}
@ -806,7 +806,7 @@ namespace Opm {
void EclipseState::handleBOXKeyword(DeckKeywordConstPtr deckKeyword, ParserLogPtr /*parserLog*/, BoxManager& boxManager) {
void EclipseState::handleBOXKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr /*logger*/, BoxManager& boxManager) {
DeckRecordConstPtr record = deckKeyword->getRecord(0);
int I1 = record->getItem("I1")->getInt(0) - 1;
int I2 = record->getItem("I2")->getInt(0) - 1;
@ -824,13 +824,13 @@ namespace Opm {
}
void EclipseState::handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword, ParserLogPtr parserLog, BoxManager& boxManager, int enabledTypes) {
void EclipseState::handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, BoxManager& boxManager, int enabledTypes) {
for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
const std::string& field = record->getItem("field")->getString(0);
double scaleFactor = record->getItem("factor")->getRawDouble(0);
setKeywordBox(deckKeyword, recordIdx, parserLog, boxManager);
setKeywordBox(deckKeyword, recordIdx, logger, boxManager);
if (m_intGridProperties->hasKeyword( field )) {
if (enabledTypes & IntProperties) {
@ -856,13 +856,13 @@ namespace Opm {
some state dependent semantics regarding endpoint scaling arrays
in the PROPS section. That is not supported.
*/
void EclipseState::handleADDKeyword(DeckKeywordConstPtr deckKeyword, ParserLogPtr parserLog, BoxManager& boxManager, int enabledTypes) {
void EclipseState::handleADDKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, BoxManager& boxManager, int enabledTypes) {
for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
const std::string& field = record->getItem("field")->getString(0);
double shiftValue = record->getItem("shift")->getRawDouble(0);
setKeywordBox(deckKeyword, recordIdx, parserLog, boxManager);
setKeywordBox(deckKeyword, recordIdx, logger, boxManager);
if (m_intGridProperties->hasKeyword( field )) {
if (enabledTypes & IntProperties) {
@ -886,13 +886,13 @@ namespace Opm {
}
void EclipseState::handleEQUALSKeyword(DeckKeywordConstPtr deckKeyword, ParserLogPtr parserLog, BoxManager& boxManager, int enabledTypes) {
void EclipseState::handleEQUALSKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, BoxManager& boxManager, int enabledTypes) {
for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
const std::string& field = record->getItem("field")->getString(0);
double value = record->getItem("value")->getRawDouble(0);
setKeywordBox(deckKeyword, recordIdx, parserLog, boxManager);
setKeywordBox(deckKeyword, recordIdx, logger, boxManager);
if (m_intGridProperties->supportsKeyword( field )) {
if (enabledTypes & IntProperties) {
@ -917,13 +917,13 @@ namespace Opm {
void EclipseState::handleCOPYKeyword(DeckKeywordConstPtr deckKeyword, ParserLogPtr parserLog, BoxManager& boxManager, int enabledTypes) {
void EclipseState::handleCOPYKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, BoxManager& boxManager, int enabledTypes) {
for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
const std::string& srcField = record->getItem("src")->getString(0);
const std::string& targetField = record->getItem("target")->getString(0);
setKeywordBox(deckKeyword, recordIdx, parserLog, boxManager);
setKeywordBox(deckKeyword, recordIdx, logger, boxManager);
if (m_intGridProperties->hasKeyword( srcField )) {
if (enabledTypes & IntProperties)
@ -957,7 +957,7 @@ namespace Opm {
void EclipseState::setKeywordBox(DeckKeywordConstPtr deckKeyword, size_t recordIdx, ParserLogPtr parserLog, BoxManager& boxManager) {
void EclipseState::setKeywordBox(DeckKeywordConstPtr deckKeyword, size_t recordIdx, LoggerPtr logger, BoxManager& boxManager) {
auto deckRecord = deckKeyword->getRecord(recordIdx);
DeckItemConstPtr I1Item = deckRecord->getItem("I1");
@ -995,17 +995,17 @@ namespace Opm {
K1Item->getInt(0) - 1,
K2Item->getInt(0) - 1);
} else if (setCount != 0)
parserLog->addError(deckKeyword->getFileName(),
logger->addError(deckKeyword->getFileName(),
deckKeyword->getLineNumber(),
"BOX modifiers on keywords must be either specified completely or not at all. Ignoring.");
}
void EclipseState::complainAboutAmbiguousKeyword(DeckConstPtr deck, ParserLogPtr parserLog, const std::string& keywordName) const {
parserLog->addError("", -1,
void EclipseState::complainAboutAmbiguousKeyword(DeckConstPtr deck, LoggerPtr logger, const std::string& keywordName) const {
logger->addError("", -1,
"The "+keywordName+" keyword must be unique in the deck. Ignoring all!");
auto keywords = deck->getKeywordList(keywordName);
for (size_t i = 0; i < keywords.size(); ++i)
parserLog->addError(keywords[i]->getFileName(), keywords[i]->getLineNumber(),
logger->addError(keywords[i]->getFileName(), keywords[i]->getLineNumber(),
"Ambiguous keyword "+keywordName+" defined here");
}

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

@ -21,7 +21,7 @@
#define OPM_ECLIPSE_STATE_HPP
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Parser/ParserLog.hpp>
#include <opm/parser/eclipse/Log/Logger.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
@ -67,7 +67,7 @@ namespace Opm {
AllProperties = IntProperties | DoubleProperties
};
EclipseState(DeckConstPtr deck, ParserLogPtr parserLog = std::make_shared<ParserLog>(&std::cout));
EclipseState(DeckConstPtr deck, LoggerPtr logger = std::make_shared<Logger>(&std::cout));
ScheduleConstPtr getSchedule() const;
EclipseGridConstPtr getEclipseGrid() const;
@ -83,7 +83,7 @@ namespace Opm {
void loadGridPropertyFromDeckKeyword(std::shared_ptr<const Box> inputBox,
DeckKeywordConstPtr deckKeyword,
ParserLogPtr parserLog,
LoggerPtr logger,
int enabledTypes = AllProperties);
std::shared_ptr<const FaultCollection> getFaults() const;
@ -119,25 +119,25 @@ namespace Opm {
std::shared_ptr<const UnitSystem> getDeckUnitSystem() const;
private:
void initTables(DeckConstPtr deck, ParserLogPtr parserLog);
void initSchedule(DeckConstPtr deck, ParserLogPtr parserLog);
void initEclipseGrid(DeckConstPtr deck, ParserLogPtr parserLog);
void initPhases(DeckConstPtr deck, ParserLogPtr parserLog);
void initTitle(DeckConstPtr deck, ParserLogPtr parserLog);
void initProperties(DeckConstPtr deck, ParserLogPtr parserLog);
void initTransMult(ParserLogPtr parserLog);
void initFaults(DeckConstPtr deck, ParserLogPtr parserLog);
void initTables(DeckConstPtr deck, LoggerPtr logger);
void initSchedule(DeckConstPtr deck, LoggerPtr logger);
void initEclipseGrid(DeckConstPtr deck, LoggerPtr logger);
void initPhases(DeckConstPtr deck, LoggerPtr logger);
void initTitle(DeckConstPtr deck, LoggerPtr logger);
void initProperties(DeckConstPtr deck, LoggerPtr logger);
void initTransMult(LoggerPtr logger);
void initFaults(DeckConstPtr deck, LoggerPtr logger);
template <class TableType>
void initSimpleTables(DeckConstPtr deck,
ParserLogPtr parserLog,
LoggerPtr logger,
const std::string& keywordName,
std::vector<TableType>& tableVector) {
if (!deck->hasKeyword(keywordName))
return; // the table is not featured by the deck...
if (deck->numKeywords(keywordName) > 1) {
complainAboutAmbiguousKeyword(deck, parserLog, keywordName);
complainAboutAmbiguousKeyword(deck, logger, keywordName);
return;
}
@ -147,7 +147,7 @@ namespace Opm {
// for simple tables, an empty record indicates that the previous table
// should be copied...
if (tableIdx == 0) {
parserLog->addError(tableKeyword->getFileName(),
logger->addError(tableKeyword->getFileName(),
tableKeyword->getLineNumber(),
"The first table for keyword "+keywordName+
" must be explicitly defined! Ignoring keyword");
@ -164,14 +164,14 @@ namespace Opm {
template <class TableType>
void initFullTables(DeckConstPtr deck,
ParserLogPtr parserLog,
LoggerPtr logger,
const std::string& keywordName,
std::vector<TableType>& tableVector) {
if (!deck->hasKeyword(keywordName))
return; // the table is not featured by the deck...
if (deck->numKeywords(keywordName) > 1) {
complainAboutAmbiguousKeyword(deck, parserLog, keywordName);
complainAboutAmbiguousKeyword(deck, logger, keywordName);
return;
}
@ -184,28 +184,28 @@ namespace Opm {
}
}
void initRocktabTables(DeckConstPtr deck, ParserLogPtr parserLog);
void initRocktabTables(DeckConstPtr deck, LoggerPtr logger);
void setMULTFLT(std::shared_ptr<const Section> section, ParserLogPtr parserLog) const;
void initMULTREGT(DeckConstPtr deck, ParserLogPtr parserLog);
void setMULTFLT(std::shared_ptr<const Section> section, LoggerPtr logger) const;
void initMULTREGT(DeckConstPtr deck, LoggerPtr logger);
double getSIScaling(const std::string &dimensionString) const;
void processGridProperties(Opm::DeckConstPtr deck, ParserLogPtr parserLog, int enabledTypes);
void scanSection(std::shared_ptr<Opm::Section> section, ParserLogPtr parserLog, int enabledTypes);
void handleADDKeyword(DeckKeywordConstPtr deckKeyword , ParserLogPtr parserLog, BoxManager& boxManager, int enabledTypes);
void handleBOXKeyword(DeckKeywordConstPtr deckKeyword , ParserLogPtr parserLog, BoxManager& boxManager);
void handleCOPYKeyword(DeckKeywordConstPtr deckKeyword , ParserLogPtr parserLog, BoxManager& boxManager, int enabledTypes);
void processGridProperties(Opm::DeckConstPtr deck, LoggerPtr logger, int enabledTypes);
void scanSection(std::shared_ptr<Opm::Section> section, LoggerPtr logger, int enabledTypes);
void handleADDKeyword(DeckKeywordConstPtr deckKeyword , LoggerPtr logger, BoxManager& boxManager, int enabledTypes);
void handleBOXKeyword(DeckKeywordConstPtr deckKeyword , LoggerPtr logger, BoxManager& boxManager);
void handleCOPYKeyword(DeckKeywordConstPtr deckKeyword , LoggerPtr logger, BoxManager& boxManager, int enabledTypes);
void handleENDBOXKeyword(BoxManager& boxManager);
void handleEQUALSKeyword(DeckKeywordConstPtr deckKeyword , ParserLogPtr parserLog, BoxManager& boxManager, int enabledTypes);
void handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword , ParserLogPtr parserLog, BoxManager& boxManager, int enabledTypes);
void handleEQUALSKeyword(DeckKeywordConstPtr deckKeyword , LoggerPtr logger, BoxManager& boxManager, int enabledTypes);
void handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword , LoggerPtr logger, BoxManager& boxManager, int enabledTypes);
void setKeywordBox(DeckKeywordConstPtr deckKeyword, size_t recordIdx, ParserLogPtr parserLog, BoxManager& boxManager);
void setKeywordBox(DeckKeywordConstPtr deckKeyword, size_t recordIdx, LoggerPtr logger, BoxManager& boxManager);
void copyIntKeyword(const std::string& srcField , const std::string& targetField , std::shared_ptr<const Box> inputBox);
void copyDoubleKeyword(const std::string& srcField , const std::string& targetField , std::shared_ptr<const Box> inputBox);
void complainAboutAmbiguousKeyword(DeckConstPtr deck, ParserLogPtr parserLog, const std::string& keywordName) const;
void complainAboutAmbiguousKeyword(DeckConstPtr deck, LoggerPtr logger, const std::string& keywordName) const;
EclipseGridConstPtr m_eclipseGrid;
ScheduleConstPtr schedule;

33
opm/parser/eclipse/EclipseState/Grid/EclipseGrid.cpp
View File

@ -28,6 +28,7 @@
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
#include <ert/ecl/ecl_grid.h>
namespace Opm {
/**
@ -90,7 +91,7 @@ namespace Opm {
}
} // anonymous namespace
EclipseGrid::EclipseGrid(std::shared_ptr<const Deck> deck, ParserLogPtr parserLog)
EclipseGrid::EclipseGrid(std::shared_ptr<const Deck> deck, LoggerPtr logger)
: m_minpv("MINPV"),
m_pinch("PINCH")
{
@ -102,10 +103,10 @@ namespace Opm {
if (runspecSection->hasKeyword("DIMENS")) {
DeckKeywordConstPtr dimens = runspecSection->getKeyword("DIMENS");
std::vector<int> dims = getDims(dimens);
initGrid(dims, deck, parserLog);
initGrid(dims, deck, logger);
} else {
const std::string msg = "The RUNSPEC section must have the DIMENS keyword with logically Cartesian grid dimensions.";
parserLog->addError("", -1, msg);
logger->addError("", -1, msg);
throw std::invalid_argument(msg);
}
} else if (hasGRID) {
@ -113,10 +114,10 @@ namespace Opm {
if (deck->hasKeyword("SPECGRID")) {
DeckKeywordConstPtr specgrid = deck->getKeyword("SPECGRID");
std::vector<int> dims = getDims(specgrid);
initGrid(dims, deck, parserLog);
initGrid(dims, deck, logger);
} else {
const std::string msg = "With no RUNSPEC section, the GRID section must specify the grid dimensions using the SPECGRID keyword.";
parserLog->addError("", -1, msg);
logger->addError("", -1, msg);
throw std::invalid_argument(msg);
}
} else {
@ -125,27 +126,27 @@ namespace Opm {
if (deck->hasKeyword("SPECGRID")) {
DeckKeywordConstPtr specgrid = deck->getKeyword("SPECGRID");
std::vector<int> dims = getDims(specgrid);
initGrid(dims, deck, parserLog);
initGrid(dims, deck, logger);
} else if (deck->hasKeyword("DIMENS")) {
DeckKeywordConstPtr dimens = deck->getKeyword("DIMENS");
std::vector<int> dims = getDims(dimens);
initGrid(dims, deck, parserLog);
initGrid(dims, deck, logger);
} else {
const std::string msg = "The deck must specify grid dimensions using either DIMENS or SPECGRID.";
parserLog->addError("", -1, msg);
logger->addError("", -1, msg);
throw std::invalid_argument(msg);
}
}
}
void EclipseGrid::initGrid( const std::vector<int>& dims, DeckConstPtr deck, ParserLogPtr parserLog) {
void EclipseGrid::initGrid( const std::vector<int>& dims, DeckConstPtr deck, LoggerPtr logger) {
m_nx = static_cast<size_t>(dims[0]);
m_ny = static_cast<size_t>(dims[1]);
m_nz = static_cast<size_t>(dims[2]);
if (hasCornerPointKeywords(deck)) {
initCornerPointGrid(dims , deck, parserLog);
initCornerPointGrid(dims , deck, logger);
} else if (hasCartesianKeywords(deck)) {
initCartesianGrid(dims , deck);
}
@ -241,8 +242,8 @@ namespace Opm {
void EclipseGrid::initCornerPointGrid(const std::vector<int>& dims , DeckConstPtr deck, ParserLogPtr parserLog) {
assertCornerPointKeywords( dims , deck, parserLog);
void EclipseGrid::initCornerPointGrid(const std::vector<int>& dims , DeckConstPtr deck, LoggerPtr logger) {
assertCornerPointKeywords( dims , deck, logger);
{
DeckKeywordConstPtr ZCORNKeyWord = deck->getKeyword("ZCORN");
DeckKeywordConstPtr COORDKeyWord = deck->getKeyword("COORD");
@ -300,7 +301,7 @@ namespace Opm {
}
void EclipseGrid::assertCornerPointKeywords( const std::vector<int>& dims , DeckConstPtr deck, ParserLogPtr parserLog)
void EclipseGrid::assertCornerPointKeywords( const std::vector<int>& dims , DeckConstPtr deck, LoggerPtr logger)
{
const int nx = dims[0];
const int ny = dims[1];
@ -314,7 +315,7 @@ namespace Opm {
+ std::to_string(static_cast<long long>(8*nx*ny*nz)) + " is "
+ std::to_string(static_cast<long long>(ZCORNKeyWord->getDataSize()));
parserLog->addError("", -1, msg);
logger->addError("", -1, msg);
throw std::invalid_argument(msg);
}
}
@ -326,7 +327,7 @@ namespace Opm {
"Wrong size of the COORD keyword: Expected 8*(nx + 1)*(ny + 1) = "
+ std::to_string(static_cast<long long>(8*(nx + 1)*(ny + 1))) + " is "
+ std::to_string(static_cast<long long>(COORDKeyWord->getDataSize()));
parserLog->addError("", -1, msg);
logger->addError("", -1, msg);
throw std::invalid_argument(msg);
}
}
@ -338,7 +339,7 @@ namespace Opm {
"Wrong size of the ACTNUM keyword: Expected nx*ny*nz = "
+ std::to_string(static_cast<long long>(nx*ny*nz)) + " is "
+ std::to_string(static_cast<long long>(ACTNUMKeyWord->getDataSize()));
parserLog->addError("", -1, msg);
logger->addError("", -1, msg);
throw std::invalid_argument(msg);
}
}

11
opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp
View File

@ -21,7 +21,8 @@
#ifndef ECLIPSE_GRID_HPP_
#define ECLIPSE_GRID_HPP_
#include <opm/parser/eclipse/Parser/ParserLog.hpp>
#include <opm/parser/eclipse/Log/Logger.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/Section.hpp>
@ -68,7 +69,7 @@ namespace Opm {
explicit EclipseGrid(const std::string& filename);
explicit EclipseGrid(const ecl_grid_type * src_ptr);
explicit EclipseGrid(size_t nx, size_t ny , size_t nz);
explicit EclipseGrid(std::shared_ptr<const Deck> deck, ParserLogPtr parserLog = std::make_shared<ParserLog>());
explicit EclipseGrid(std::shared_ptr<const Deck> deck, LoggerPtr logger = std::make_shared<Logger>());
static bool hasCornerPointKeywords(std::shared_ptr<const Deck> deck);
static bool hasCartesianKeywords(std::shared_ptr<const Deck> deck);
@ -111,12 +112,12 @@ namespace Opm {
void assertCellInfo() const;
void initCartesianGrid(const std::vector<int>& dims , DeckConstPtr deck);
void initCornerPointGrid(const std::vector<int>& dims , DeckConstPtr deck, ParserLogPtr parserLog);
void initCornerPointGrid(const std::vector<int>& dims , DeckConstPtr deck, LoggerPtr logger);
void initDTOPSGrid(const std::vector<int>& dims , DeckConstPtr deck);
void initDVDEPTHZGrid(const std::vector<int>& dims , DeckConstPtr deck);
void initGrid(const std::vector<int>& dims, DeckConstPtr deck, ParserLogPtr parserLog);
void initGrid(const std::vector<int>& dims, DeckConstPtr deck, LoggerPtr logger);
static void assertCornerPointKeywords(const std::vector<int>& dims, DeckConstPtr deck, ParserLogPtr parserLog) ;
static void assertCornerPointKeywords(const std::vector<int>& dims, DeckConstPtr deck, LoggerPtr logger) ;
static bool hasDVDEPTHZKeywords(DeckConstPtr deck);
static bool hasDTOPSKeywords(DeckConstPtr deck);
static void assertVectorSize(const std::vector<double>& vector , size_t expectedSize , const std::string& msg);

17
opm/parser/eclipse/EclipseState/Grid/tests/MULTREGTScannerTests.cpp
View File

@ -25,6 +25,14 @@
#include <boost/test/unit_test.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <opm/parser/eclipse/Log/Logger.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/MULTREGTScanner.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
@ -32,12 +40,7 @@
#include <opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/Box.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaceDir.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Parser/ParserLog.hpp>
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
@ -232,6 +235,6 @@ static Opm::DeckPtr createCopyMULTNUMDeck() {
BOOST_AUTO_TEST_CASE(MULTREGT_COPY_MULTNUM) {
Opm::DeckPtr deck = createCopyMULTNUMDeck();
Opm::ParserLogPtr parserLog(new Opm::ParserLog());
BOOST_CHECK_NO_THROW( Opm::EclipseState( deck, parserLog ));
Opm::LoggerPtr logger(new Opm::Logger());
BOOST_CHECK_NO_THROW( Opm::EclipseState( deck, logger ));
}

101
opm/parser/eclipse/EclipseState/Schedule/Schedule.cpp
View File

@ -17,35 +17,38 @@
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <string>
#include <vector>
#include <boost/algorithm/string.hpp>
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellProductionProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellInjectionProperties.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/WellPolymerProperties.hpp>
#include <opm/parser/eclipse/Deck/Section.hpp>
#include <boost/algorithm/string.hpp>
#include <string>
#include <vector>
namespace Opm {
Schedule::Schedule(DeckConstPtr deck, ParserLogPtr parserLog) {
initFromDeck(deck, parserLog);
Schedule::Schedule(DeckConstPtr deck, LoggerPtr logger) {
initFromDeck(deck, logger);
}
void Schedule::initFromDeck(DeckConstPtr deck, ParserLogPtr parserLog) {
createTimeMap(deck, parserLog);
void Schedule::initFromDeck(DeckConstPtr deck, LoggerPtr logger) {
createTimeMap(deck, logger);
addGroup( "FIELD", 0 );
initRootGroupTreeNode(getTimeMap());
iterateScheduleSection(deck, parserLog);
iterateScheduleSection(deck, logger);
}
void Schedule::initRootGroupTreeNode(TimeMapConstPtr timeMap) {
m_rootGroupTree.reset(new DynamicState<GroupTreePtr>(timeMap, GroupTreePtr(new GroupTree())));
}
void Schedule::createTimeMap(DeckConstPtr deck, ParserLogPtr /*parserLog*/) {
void Schedule::createTimeMap(DeckConstPtr deck, LoggerPtr /*logger*/) {
boost::posix_time::ptime startTime(defaultStartDate);
if (deck->hasKeyword("START")) {
DeckKeywordConstPtr startKeyword = deck->getKeyword("START");
@ -55,66 +58,66 @@ namespace Opm {
m_timeMap.reset(new TimeMap(startTime));
}
void Schedule::iterateScheduleSection(DeckConstPtr deck, ParserLogPtr parserLog) {
void Schedule::iterateScheduleSection(DeckConstPtr deck, LoggerPtr logger) {
size_t currentStep = 0;
for (size_t keywordIdx = 0; keywordIdx < deck->size(); ++keywordIdx) {
DeckKeywordConstPtr keyword = deck->getKeyword(keywordIdx);
if (keyword->name() == "DATES") {
handleDATES(keyword, parserLog);
handleDATES(keyword, logger);
currentStep += keyword->size();
}
if (keyword->name() == "TSTEP") {
handleTSTEP(keyword, parserLog);
handleTSTEP(keyword, logger);
currentStep += keyword->getRecord(0)->getItem(0)->size(); // This is a bit weird API.
}
if (keyword->name() == "WELSPECS") {
handleWELSPECS(keyword, parserLog, currentStep);
handleWELSPECS(keyword, logger, currentStep);
}
if (keyword->name() == "WCONHIST")
handleWCONHIST(keyword, parserLog, currentStep);
handleWCONHIST(keyword, logger, currentStep);
if (keyword->name() == "WCONPROD")
handleWCONPROD(keyword, parserLog, currentStep);
handleWCONPROD(keyword, logger, currentStep);
if (keyword->name() == "WCONINJE")
handleWCONINJE(deck, keyword, parserLog, currentStep);
handleWCONINJE(deck, keyword, logger, currentStep);
if (keyword->name() == "WPOLYMER")
handleWPOLYMER(keyword, parserLog, currentStep);
handleWPOLYMER(keyword, logger, currentStep);
if (keyword->name() == "WCONINJH")
handleWCONINJH(deck, keyword, parserLog, currentStep);
handleWCONINJH(deck, keyword, logger, currentStep);
if (keyword->name() == "WGRUPCON")
handleWGRUPCON(keyword, parserLog, currentStep);
handleWGRUPCON(keyword, logger, currentStep);
if (keyword->name() == "COMPDAT")
handleCOMPDAT(keyword, parserLog, currentStep);
handleCOMPDAT(keyword, logger, currentStep);
if (keyword->name() == "WELOPEN")
handleWELOPEN(keyword, parserLog, currentStep);
handleWELOPEN(keyword, logger, currentStep);
if (keyword->name() == "GRUPTREE")
handleGRUPTREE(keyword, parserLog, currentStep);
handleGRUPTREE(keyword, logger, currentStep);
if (keyword->name() == "GCONINJE")
handleGCONINJE(deck, keyword, parserLog, currentStep);
handleGCONINJE(deck, keyword, logger, currentStep);
if (keyword->name() == "GCONPROD")
handleGCONPROD(keyword, parserLog, currentStep);
handleGCONPROD(keyword, logger, currentStep);
}
}
void Schedule::handleDATES(DeckKeywordConstPtr keyword, ParserLogPtr /*parserLog*/) {
void Schedule::handleDATES(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/) {
m_timeMap->addFromDATESKeyword(keyword);
}
void Schedule::handleTSTEP(DeckKeywordConstPtr keyword, ParserLogPtr /*parserLog*/) {
void Schedule::handleTSTEP(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/) {
m_timeMap->addFromTSTEPKeyword(keyword);
}
@ -127,7 +130,7 @@ namespace Opm {
return treeUpdated;
}
void Schedule::handleWELSPECS(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep) {
void Schedule::handleWELSPECS(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep) {
bool needNewTree = false;
GroupTreePtr newTree = m_rootGroupTree->get(currentStep)->deepCopy();
@ -145,7 +148,7 @@ namespace Opm {
}
WellConstPtr currentWell = getWell(wellName);
checkWELSPECSConsistency(currentWell, keyword, recordNr, parserLog);
checkWELSPECSConsistency(currentWell, keyword, recordNr, logger);
addWellToGroup( getGroup(groupName) , getWell(wellName) , currentStep);
bool treeChanged = handleGroupFromWELSPECS(groupName, newTree);
@ -156,12 +159,12 @@ namespace Opm {
}
}
void Schedule::checkWELSPECSConsistency(WellConstPtr well, DeckKeywordConstPtr keyword, size_t recordIdx, ParserLogPtr parserLog) const {
void Schedule::checkWELSPECSConsistency(WellConstPtr well, DeckKeywordConstPtr keyword, size_t recordIdx, LoggerPtr logger) const {
DeckRecordConstPtr record = keyword->getRecord(recordIdx);
if (well->getHeadI() != record->getItem("HEAD_I")->getInt(0) - 1) {
std::string msg =
"Unable process WELSPECS for well " + well->name() + ", HEAD_I deviates from existing value";
parserLog->addError(keyword->getFileName(),
logger->addError(keyword->getFileName(),
keyword->getLineNumber(),
msg);
throw std::invalid_argument(msg);
@ -169,7 +172,7 @@ namespace Opm {
if (well->getHeadJ() != record->getItem("HEAD_J")->getInt(0) - 1) {
std::string msg =
"Unable process WELSPECS for well " + well->name() + ", HEAD_J deviates from existing value";
parserLog->addError(keyword->getFileName(),
logger->addError(keyword->getFileName(),
keyword->getLineNumber(),
msg);
throw std::invalid_argument(msg);
@ -177,7 +180,7 @@ namespace Opm {
if (well->getRefDepthDefaulted() != record->getItem("REF_DEPTH")->defaultApplied(0)) {
std::string msg =
"Unable process WELSPECS for well " + well->name() + ", REF_DEPTH defaulted state deviates from existing value";
parserLog->addError(keyword->getFileName(),
logger->addError(keyword->getFileName(),
keyword->getLineNumber(),
msg);
throw std::invalid_argument(msg);
@ -186,7 +189,7 @@ namespace Opm {
if (well->getRefDepth() != record->getItem("REF_DEPTH")->getSIDouble(0)) {
std::string msg =
"Unable process WELSPECS for well " + well->name() + ", REF_DEPTH deviates from existing value";
parserLog->addError(keyword->getFileName(),
logger->addError(keyword->getFileName(),
keyword->getLineNumber(),
msg);
throw std::invalid_argument(msg);
@ -194,7 +197,7 @@ namespace Opm {
}
}
void Schedule::handleWCONProducer(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep, bool isPredictionMode) {
void Schedule::handleWCONProducer(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep, bool isPredictionMode) {
for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
DeckRecordConstPtr record = keyword->getRecord(recordNr);
@ -235,7 +238,7 @@ namespace Opm {
std::string msg =
"Tried to set invalid control: " +
cmodeString + " for well: " + well->name();
parserLog->addError(keyword->getFileName(),
logger->addError(keyword->getFileName(),
keyword->getLineNumber(),
msg);
throw std::invalid_argument(msg);
@ -248,15 +251,15 @@ namespace Opm {
}
}
void Schedule::handleWCONHIST(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep) {
handleWCONProducer(keyword, parserLog, currentStep, false);
void Schedule::handleWCONHIST(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep) {
handleWCONProducer(keyword, logger, currentStep, false);
}
void Schedule::handleWCONPROD(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep) {
handleWCONProducer(keyword, parserLog, currentStep, true);
void Schedule::handleWCONPROD(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep) {
handleWCONProducer(keyword, logger, currentStep, true);
}
void Schedule::handleWCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, ParserLogPtr /*parserLog*/, size_t currentStep) {
void Schedule::handleWCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
DeckRecordConstPtr record = keyword->getRecord(recordNr);
const std::string& wellNamePattern = record->getItem("WELL")->getTrimmedString(0);
@ -325,7 +328,7 @@ namespace Opm {
}
void Schedule::handleWPOLYMER(DeckKeywordConstPtr keyword, ParserLogPtr /*parserLog*/, size_t currentStep) {
void Schedule::handleWPOLYMER(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
DeckRecordConstPtr record = keyword->getRecord(recordNr);
const std::string& wellNamePattern = record->getItem("WELL")->getTrimmedString(0);
@ -354,7 +357,7 @@ namespace Opm {
}
}
void Schedule::handleWCONINJH(DeckConstPtr deck, DeckKeywordConstPtr keyword, ParserLogPtr /*parserLog*/, size_t currentStep) {
void Schedule::handleWCONINJH(DeckConstPtr deck, DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
DeckRecordConstPtr record = keyword->getRecord(recordNr);
const std::string& wellName = record->getItem("WELL")->getTrimmedString(0);
@ -385,7 +388,7 @@ namespace Opm {
}
}
void Schedule::handleWELOPEN(DeckKeywordConstPtr keyword, ParserLogPtr /*parserLog*/, size_t currentStep) {
void Schedule::handleWELOPEN(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
DeckRecordConstPtr record = keyword->getRecord(recordNr);
const std::string& wellName = record->getItem("WELL")->getTrimmedString(0);
@ -402,7 +405,7 @@ namespace Opm {
}
void Schedule::handleGCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, ParserLogPtr /*parserLog*/, size_t currentStep) {
void Schedule::handleGCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
DeckRecordConstPtr record = keyword->getRecord(recordNr);
const std::string& groupName = record->getItem("GROUP")->getTrimmedString(0);
@ -435,7 +438,7 @@ namespace Opm {
}
void Schedule::handleGCONPROD(DeckKeywordConstPtr keyword, ParserLogPtr /*parserLog*/, size_t currentStep) {
void Schedule::handleGCONPROD(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
DeckRecordConstPtr record = keyword->getRecord(recordNr);
const std::string& groupName = record->getItem("GROUP")->getTrimmedString(0);
@ -457,7 +460,7 @@ namespace Opm {
}
}
void Schedule::handleCOMPDAT(DeckKeywordConstPtr keyword, ParserLogPtr /*parserLog*/, size_t currentStep) {
void Schedule::handleCOMPDAT(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
std::map<std::string , std::vector< CompletionPtr> > completionMapList = Completion::completionsFromCOMPDATKeyword( keyword );
std::map<std::string , std::vector< CompletionPtr> >::iterator iter;
@ -468,7 +471,7 @@ namespace Opm {
}
}
void Schedule::handleWGRUPCON(DeckKeywordConstPtr keyword, ParserLogPtr /*parserLog*/, size_t currentStep) {
void Schedule::handleWGRUPCON(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {
DeckRecordConstPtr record = keyword->getRecord(recordNr);
const std::string& wellName = record->getItem("WELL")->getTrimmedString(0);
@ -489,7 +492,7 @@ namespace Opm {
}
}
void Schedule::handleGRUPTREE(DeckKeywordConstPtr keyword, ParserLogPtr /*parserLog*/, size_t currentStep) {
void Schedule::handleGRUPTREE(DeckKeywordConstPtr keyword, LoggerPtr /*logger*/, size_t currentStep) {
GroupTreePtr currentTree = m_rootGroupTree->get(currentStep);
GroupTreePtr newTree = currentTree->deepCopy();
for (size_t recordNr = 0; recordNr < keyword->size(); recordNr++) {

43
opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp
View File

@ -19,6 +19,8 @@
#ifndef SCHEDULE_HPP
#define SCHEDULE_HPP
#include <opm/parser/eclipse/Log/Logger.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
#include <opm/parser/eclipse/EclipseState/Schedule/GroupTree.hpp>
@ -26,7 +28,6 @@
#include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>
#include <opm/parser/eclipse/EclipseState/Util/OrderedMap.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Parser/ParserLog.hpp>
#include <memory>
#include <boost/date_time/posix_time/posix_time.hpp>
@ -40,7 +41,7 @@ namespace Opm
class Schedule {
public:
Schedule(DeckConstPtr deck, ParserLogPtr parserLog=std::make_shared<ParserLog>());
Schedule(DeckConstPtr deck, LoggerPtr logger=std::make_shared<Logger>());
boost::posix_time::ptime getStartTime() const
{ return m_timeMap->getStartTime(/*timeStepIdx=*/0); }
TimeMapConstPtr getTimeMap() const;
@ -67,29 +68,29 @@ namespace Opm
std::shared_ptr<DynamicState<GroupTreePtr> > m_rootGroupTree;
void addWellToGroup( GroupPtr newGroup , WellPtr well , size_t timeStep);
void initFromDeck(DeckConstPtr deck, ParserLogPtr parserLog);
void createTimeMap(DeckConstPtr deck, ParserLogPtr parserLog);
void initFromDeck(DeckConstPtr deck, LoggerPtr logger);
void createTimeMap(DeckConstPtr deck, LoggerPtr logger);
void initRootGroupTreeNode(TimeMapConstPtr timeMap);
void iterateScheduleSection(DeckConstPtr deck, ParserLogPtr parserLog);
void iterateScheduleSection(DeckConstPtr deck, LoggerPtr logger);
bool handleGroupFromWELSPECS(const std::string& groupName, GroupTreePtr newTree) const;
void addGroup(const std::string& groupName , size_t timeStep);
void addWell(const std::string& wellName, DeckRecordConstPtr record, size_t timeStep);
void checkWELSPECSConsistency(WellConstPtr well, DeckKeywordConstPtr keyword, size_t recordIdx, ParserLogPtr parserLog) const;
void handleWELSPECS(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep);
void handleWCONProducer(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep, bool isPredictionMode);
void handleWCONHIST(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep);
void handleWCONPROD(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep);
void handleWGRUPCON(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep);
void handleCOMPDAT(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep);
void handleWCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep);
void handleWPOLYMER(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep);
void handleWCONINJH(DeckConstPtr deck, DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep);
void handleWELOPEN(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep);
void handleGCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep);
void handleGCONPROD(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep);
void handleDATES(DeckKeywordConstPtr keyword, ParserLogPtr parserLog);
void handleTSTEP(DeckKeywordConstPtr keyword, ParserLogPtr parserLog);
void handleGRUPTREE(DeckKeywordConstPtr keyword, ParserLogPtr parserLog, size_t currentStep);
void checkWELSPECSConsistency(WellConstPtr well, DeckKeywordConstPtr keyword, size_t recordIdx, LoggerPtr logger) const;
void handleWELSPECS(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
void handleWCONProducer(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep, bool isPredictionMode);
void handleWCONHIST(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
void handleWCONPROD(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
void handleWGRUPCON(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
void handleCOMPDAT(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
void handleWCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
void handleWPOLYMER(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
void handleWCONINJH(DeckConstPtr deck, DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
void handleWELOPEN(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
void handleGCONINJE(DeckConstPtr deck, DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
void handleGCONPROD(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
void handleDATES(DeckKeywordConstPtr keyword, LoggerPtr logger);
void handleTSTEP(DeckKeywordConstPtr keyword, LoggerPtr logger);
void handleGRUPTREE(DeckKeywordConstPtr keyword, LoggerPtr logger, size_t currentStep);
double convertInjectionRateToSI(double rawRate, WellInjector::TypeEnum wellType, const Opm::UnitSystem &unitSystem) const;
double convertInjectionRateToSI(double rawRate, Phase::PhaseEnum wellPhase, const Opm::UnitSystem &unitSystem) const;

6
opm/parser/eclipse/EclipseState/checkDeck.cpp
View File

@ -21,7 +21,7 @@
#include <opm/parser/eclipse/Deck/Section.hpp>
namespace Opm {
bool checkDeck(DeckConstPtr deck, ParserLogPtr parserLog, size_t enabledChecks) {
bool checkDeck(DeckConstPtr deck, LoggerPtr logger, size_t enabledChecks) {
bool deckValid = true;
// make sure that the deck does not contain unknown keywords
@ -31,7 +31,7 @@ bool checkDeck(DeckConstPtr deck, ParserLogPtr parserLog, size_t enabledChecks)
const auto& keyword = deck->getKeyword(keywordIdx);
if (!keyword->hasParserKeyword()) {
std::string msg("Keyword '" + keyword->name() + "' is unknown.");
parserLog->addWarning(keyword->getFileName(), keyword->getLineNumber(), msg);
logger->addWarning(keyword->getFileName(), keyword->getLineNumber(), msg);
deckValid = false;
}
}
@ -40,7 +40,7 @@ bool checkDeck(DeckConstPtr deck, ParserLogPtr parserLog, size_t enabledChecks)
// make sure all mandatory sections are present and that their order is correct
if (enabledChecks & SectionTopology) {
bool ensureKeywordSection = enabledChecks & KeywordSection;
deckValid = deckValid && Section::checkSectionTopology(deck, parserLog, ensureKeywordSection);
deckValid = deckValid && Section::checkSectionTopology(deck, logger, ensureKeywordSection);
}
return deckValid;

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

@ -20,8 +20,8 @@
#ifndef OPM_CHECK_DECK_HPP
#define OPM_CHECK_DECK_HPP
#include <opm/parser/eclipse/Log/Logger.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Parser/ParserLog.hpp>
namespace Opm {
enum DeckChecks {
@ -37,7 +37,7 @@ enum DeckChecks {
// some semantical correctness checks of the deck. this method adds a warning to
// the deck object if any issue is found ...
bool checkDeck(DeckConstPtr deck, ParserLogPtr parserLog, size_t enabledChecks = AllChecks);
bool checkDeck(DeckConstPtr deck, LoggerPtr logger, size_t enabledChecks = AllChecks);
}
#endif

10
opm/parser/eclipse/EclipseState/tests/EclipseStateTests.cpp
View File

@ -97,8 +97,8 @@ static DeckPtr createDeckTOP() {
BOOST_AUTO_TEST_CASE(GetPOROTOPBased) {
DeckPtr deck = createDeckTOP();
ParserLogPtr parserLog(new ParserLog());
EclipseState state(deck, parserLog);
LoggerPtr logger(new Logger());
EclipseState state(deck, logger);
std::shared_ptr<GridProperty<double> > poro = state.getDoubleGridProperty( "PORO" );
std::shared_ptr<GridProperty<double> > permx = state.getDoubleGridProperty( "PERMX" );
@ -224,12 +224,12 @@ BOOST_AUTO_TEST_CASE(IntProperties) {
BOOST_AUTO_TEST_CASE(PropertiesNotSupportedThrows) {
DeckPtr deck = createDeck();
ParserLogPtr parserLog(new ParserLog());
LoggerPtr logger(new Logger());
EclipseState state(deck);
DeckKeywordConstPtr swat = deck->getKeyword("SWAT");
BOOST_CHECK_EQUAL( false , state.supportsGridProperty("SWAT"));
state.loadGridPropertyFromDeckKeyword(std::make_shared<const Box>(10,10,10), swat, parserLog);
BOOST_CHECK(parserLog->numErrors() > 0);
state.loadGridPropertyFromDeckKeyword(std::make_shared<const Box>(10,10,10), swat, logger);
BOOST_CHECK(logger->numErrors() > 0);
}

32
opm/parser/eclipse/IntegrationTests/BoxTest.cpp
View File

@ -29,13 +29,13 @@
using namespace Opm;
// forward declaration to avoid a pedantic compiler warning
EclipseState makeState(const std::string& fileName, ParserLogPtr parserLog);
EclipseState makeState(const std::string& fileName, LoggerPtr logger);
EclipseState makeState(const std::string& fileName, ParserLogPtr parserLog) {
EclipseState makeState(const std::string& fileName, LoggerPtr logger) {
ParserPtr parser(new Parser( ));
boost::filesystem::path boxFile(fileName);
DeckPtr deck = parser->parseFile(boxFile.string());
EclipseState state(deck, parserLog);
EclipseState state(deck, logger);
return state;
}
@ -52,8 +52,8 @@ EclipseState makeState(const std::string& fileName, ParserLogPtr parserLog) {
*/
BOOST_AUTO_TEST_CASE( PERMX ) {
ParserLogPtr parserLog(new ParserLog());
EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1" , parserLog);
LoggerPtr logger(new Logger());
EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1" , logger);
std::shared_ptr<GridProperty<double> > permx = state.getDoubleGridProperty("PERMX");
std::shared_ptr<GridProperty<double> > permy = state.getDoubleGridProperty("PERMY");
std::shared_ptr<GridProperty<double> > permz = state.getDoubleGridProperty("PERMZ");
@ -75,8 +75,8 @@ BOOST_AUTO_TEST_CASE( PERMX ) {
BOOST_AUTO_TEST_CASE( PARSE_BOX_OK ) {
ParserLogPtr parserLog(new ParserLog());
EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1", parserLog);
LoggerPtr logger(new Logger());
EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1", logger);
std::shared_ptr<GridProperty<int> > satnum = state.getIntGridProperty("SATNUM");
{
size_t i,j,k;
@ -100,8 +100,8 @@ BOOST_AUTO_TEST_CASE( PARSE_BOX_OK ) {
BOOST_AUTO_TEST_CASE( PARSE_MULTIPLY_COPY ) {
ParserLogPtr parserLog(new ParserLog());
EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1", parserLog);
LoggerPtr logger(new Logger());
EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1", logger);
std::shared_ptr<GridProperty<int> > satnum = state.getIntGridProperty("SATNUM");
std::shared_ptr<GridProperty<int> > fipnum = state.getIntGridProperty("FIPNUM");
size_t i,j,k;
@ -124,22 +124,22 @@ BOOST_AUTO_TEST_CASE( PARSE_MULTIPLY_COPY ) {
BOOST_AUTO_TEST_CASE( INCOMPLETE_KEYWORD_BOX) {
ParserLogPtr parserLog(new ParserLog());
makeState("testdata/integration_tests/BOX/BOXTEST2", parserLog);
BOOST_CHECK(parserLog->numErrors() > 1);
LoggerPtr logger(new Logger());
makeState("testdata/integration_tests/BOX/BOXTEST2", logger);
BOOST_CHECK(logger->numErrors() > 1);
}
BOOST_AUTO_TEST_CASE( KEYWORD_BOX_TOO_SMALL) {
ParserLogPtr parserLog(new ParserLog());
BOOST_CHECK_THROW( makeState("testdata/integration_tests/BOX/BOXTEST3", parserLog) , std::invalid_argument);
LoggerPtr logger(new Logger());
BOOST_CHECK_THROW( makeState("testdata/integration_tests/BOX/BOXTEST3", logger) , std::invalid_argument);
}
BOOST_AUTO_TEST_CASE( EQUAL ) {
ParserLogPtr parserLog(new ParserLog());
EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1", parserLog);
LoggerPtr logger(new Logger());
EclipseState state = makeState("testdata/integration_tests/BOX/BOXTEST1", logger);
std::shared_ptr<GridProperty<int> > pvtnum = state.getIntGridProperty("PVTNUM");
std::shared_ptr<GridProperty<int> > eqlnum = state.getIntGridProperty("EQLNUM");
std::shared_ptr<GridProperty<double> > poro = state.getDoubleGridProperty("PORO");

18
opm/parser/eclipse/IntegrationTests/CheckDeckValidity.cpp
View File

@ -50,8 +50,8 @@ BOOST_AUTO_TEST_CASE( KeywordInCorrectSection ) {
"SCHEDULE\n";
auto deck = parser->parseString(correctDeckString);
Opm::ParserLogPtr parserLog(new Opm::ParserLog());
BOOST_CHECK(Opm::checkDeck(deck, parserLog));
Opm::LoggerPtr logger(new Opm::Logger());
BOOST_CHECK(Opm::checkDeck(deck, logger));
}
{
@ -64,9 +64,9 @@ BOOST_AUTO_TEST_CASE( KeywordInCorrectSection ) {
"SCHEDULE\n";
auto deck = parser->parseString(correctDeckString);
Opm::ParserLogPtr parserLog(new Opm::ParserLog());
BOOST_CHECK(!Opm::checkDeck(deck, parserLog));
BOOST_CHECK(Opm::checkDeck(deck, parserLog, ~Opm::SectionTopology));
Opm::LoggerPtr logger(new Opm::Logger());
BOOST_CHECK(!Opm::checkDeck(deck, logger));
BOOST_CHECK(Opm::checkDeck(deck, logger, ~Opm::SectionTopology));
}
{
@ -91,14 +91,14 @@ BOOST_AUTO_TEST_CASE( KeywordInCorrectSection ) {
"SCHEDULE\n";
auto deck = parser->parseString(incorrectDeckString);
Opm::ParserLogPtr parserLog(new Opm::ParserLog());
BOOST_CHECK(!Opm::checkDeck(deck, parserLog));
Opm::LoggerPtr logger(new Opm::Logger());
BOOST_CHECK(!Opm::checkDeck(deck, logger));
// this is supposed to succeed as we don't ensure that all keywords are in the
// correct section
BOOST_CHECK(Opm::checkDeck(deck, parserLog, Opm::SectionTopology));
BOOST_CHECK(Opm::checkDeck(deck, logger, Opm::SectionTopology));
// this fails because of the incorrect BOX keyword
BOOST_CHECK(!Opm::checkDeck(deck, parserLog, Opm::SectionTopology | Opm::KeywordSection));
BOOST_CHECK(!Opm::checkDeck(deck, logger, Opm::SectionTopology | Opm::KeywordSection));
}
}

10
opm/parser/eclipse/IntegrationTests/ParseACTION.cpp
View File

@ -52,8 +52,8 @@ BOOST_AUTO_TEST_CASE( parse_ACTION_OK ) {
BOOST_REQUIRE_THROW( parser->parseFile(actionFile2.string()) , std::invalid_argument );
ParserLogPtr parserLog(new ParserLog);
DeckPtr deck = parser->parseFile(actionFile.string(), parserLog);
LoggerPtr logger(new Logger);
DeckPtr deck = parser->parseFile(actionFile.string(), logger);
DeckKeywordConstPtr kw1 = deck->getKeyword("WCONHIST" , 0);
BOOST_CHECK_EQUAL( 3U , kw1->size() );
@ -76,10 +76,10 @@ BOOST_AUTO_TEST_CASE( parse_ACTION_OK ) {
BOOST_CHECK_EQUAL( false , deck->hasKeyword( "DIMENS" ));
BOOST_CHECK_EQUAL( 1U , parserLog->size() );
BOOST_CHECK_EQUAL( 1U , logger->size() );
{
BOOST_CHECK_EQUAL( actionFile.string() , parserLog->getFileName(0));
BOOST_CHECK_EQUAL( 2U , parserLog->getLineNumber(0));
BOOST_CHECK_EQUAL( actionFile.string() , logger->getFileName(0));
BOOST_CHECK_EQUAL( 2U , logger->getLineNumber(0));
}
}

44
opm/parser/eclipse/Parser/ParserLog.cpp → opm/parser/eclipse/Log/Logger.cpp
View File

@ -16,14 +16,16 @@
You should have received a copy of the GNU General Public License
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include "ParserLog.hpp"
#include <stdexcept>
#include <sstream>
#include <cassert>
#include <opm/parser/eclipse/Log/Logger.hpp>
namespace Opm {
ParserLog::ParserLog() {
Logger::Logger() {
m_numErrors = 0;
m_numWarnings = 0;
m_numNotes = 0;
@ -31,7 +33,7 @@ ParserLog::ParserLog() {
setOutStream(NULL);
}
ParserLog::ParserLog(std::ostream* os) {
Logger::Logger(std::ostream* os) {
m_numErrors = 0;
m_numWarnings = 0;
m_numNotes = 0;
@ -39,27 +41,27 @@ ParserLog::ParserLog(std::ostream* os) {
setOutStream(os);
}
void ParserLog::setOutStream(std::ostream* os) {
void Logger::setOutStream(std::ostream* os) {
m_outStream = os;
}
size_t ParserLog::size() const {
size_t Logger::size() const {
return m_messages.size();
}
size_t ParserLog::numErrors() const {
size_t Logger::numErrors() const {
return m_numErrors;
}
size_t ParserLog::numWarnings() const {
size_t Logger::numWarnings() const {
return m_numWarnings;
}
size_t ParserLog::numNotes() const {
size_t Logger::numNotes() const {
return m_numNotes;
}
void ParserLog::addMessage(const std::string& fileName,
void Logger::addMessage(const std::string& fileName,
int lineNumber,
MessageType messageType,
const std::string& description) {
@ -88,25 +90,25 @@ void ParserLog::addMessage(const std::string& fileName,
}
}
void ParserLog::addNote(const std::string& fileName,
void Logger::addNote(const std::string& fileName,
int lineNumber,
const std::string& description) {
addMessage(fileName, lineNumber, Note, description);
}
void ParserLog::addWarning(const std::string& fileName,
void Logger::addWarning(const std::string& fileName,
int lineNumber,
const std::string& description) {
addMessage(fileName, lineNumber, Warning, description);
}
void ParserLog::addError(const std::string& fileName,
void Logger::addError(const std::string& fileName,
int lineNumber,
const std::string& description) {
addMessage(fileName, lineNumber, Error, description);
}
void ParserLog::clear()
void Logger::clear()
{
m_numErrors = 0;
m_numWarnings = 0;
@ -115,7 +117,7 @@ void ParserLog::clear()
m_messages.clear();
}
void ParserLog::append(const ParserLog &other)
void Logger::append(const Logger &other)
{
for (size_t i = 0; i < other.size(); ++i) {
addMessage(other.getFileName(i),
@ -125,27 +127,27 @@ void ParserLog::append(const ParserLog &other)
}
}
const std::string& ParserLog::getFileName(size_t msgIdx) const {
const std::string& Logger::getFileName(size_t msgIdx) const {
assert(msgIdx < size());
return std::get<0>(m_messages[msgIdx]);
}
int ParserLog::getLineNumber(size_t msgIdx) const {
int Logger::getLineNumber(size_t msgIdx) const {
assert(msgIdx < size());
return std::get<1>(m_messages[msgIdx]);
}
ParserLog::MessageType ParserLog::getMessageType(size_t msgIdx) const {
Logger::MessageType Logger::getMessageType(size_t msgIdx) const {
assert(msgIdx < size());
return std::get<2>(m_messages[msgIdx]);
}
const std::string& ParserLog::getDescription(size_t msgIdx) const {
const std::string& Logger::getDescription(size_t msgIdx) const {
assert(msgIdx < size());
return std::get<3>(m_messages[msgIdx]);
}
const std::string ParserLog::getFormattedMessage(size_t msgIdx) const {
const std::string Logger::getFormattedMessage(size_t msgIdx) const {
std::ostringstream oss;
if (getLineNumber(msgIdx) > 0) {
oss << getFileName(msgIdx) << ":"
@ -167,7 +169,7 @@ const std::string ParserLog::getFormattedMessage(size_t msgIdx) const {
return oss.str();
}
void ParserLog::printAll(std::ostream& os, size_t enabledTypes) const {
void Logger::printAll(std::ostream& os, size_t enabledTypes) const {
for (size_t i = 0; i < size(); ++i)
if (enabledTypes & getMessageType(i))
os << getFormattedMessage(i) << "\n";

16
opm/parser/eclipse/Parser/ParserLog.hpp → opm/parser/eclipse/Log/Logger.hpp
View File

@ -16,8 +16,8 @@
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_PARSER_LOG_HPP
#define OPM_PARSER_LOG_HPP
#ifndef OPM_LOGGER_HPP
#define OPM_LOGGER_HPP
#include <iostream>
#include <string>
@ -30,7 +30,7 @@ namespace Opm {
* \brief Provides a simple sytem for log message which are found by the
* Parser/Deck/EclipseState classes during processing the deck.
*/
class ParserLog {
class Logger {
public:
enum MessageType {
Note = 0x01,
@ -40,8 +40,8 @@ public:
static const int AllMessageTypes = 0xff;
ParserLog();
ParserLog(std::ostream* os);
Logger();
Logger(std::ostream* os);
void setOutStream(std::ostream* os);
@ -71,7 +71,7 @@ public:
const std::string& getDescription(size_t msgIdx) const;
void clear();
void append(const ParserLog &other);
void append(const Logger &other);
/*!
* \brief This method takes the information provided by the methods above and returns
@ -107,8 +107,8 @@ private:
mutable std::ostream* m_outStream;
};
typedef std::shared_ptr<ParserLog> ParserLogPtr;
typedef std::shared_ptr<const ParserLog> ParserLogConstPtr;
typedef std::shared_ptr<Logger> LoggerPtr;
typedef std::shared_ptr<const Logger> LoggerConstPtr;
} // namespace Opm
#endif

31
opm/parser/eclipse/Parser/Parser.cpp
View File

@ -19,8 +19,9 @@
#include <memory>
#include <opm/parser/eclipse/Log/Logger.hpp>
#include <opm/parser/eclipse/Parser/Parser.hpp>
#include <opm/parser/eclipse/Parser/ParserLog.hpp>
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/parser/eclipse/RawDeck/RawConsts.hpp>
#include <opm/parser/eclipse/RawDeck/RawEnums.hpp>
@ -31,7 +32,7 @@ namespace Opm {
struct ParserState {
DeckPtr deck;
ParserLog parserLog;
Logger logger;
boost::filesystem::path dataFile;
boost::filesystem::path rootPath;
std::map<std::string, std::string> pathMap;
@ -89,7 +90,7 @@ namespace Opm {
is retained in the current implementation.
*/
DeckPtr Parser::parseFile(const std::string &dataFileName, ParserLogPtr parserLog) const {
DeckPtr Parser::parseFile(const std::string &dataFileName, LoggerPtr logger) const {
std::shared_ptr<ParserState> parserState(new ParserState(dataFileName, DeckPtr(new Deck()), getRootPathFromFile(dataFileName)));
@ -100,33 +101,33 @@ namespace Opm {
parseState(parserState);
applyUnitsToDeck(parserState->deck);
if (parserLog)
*parserLog = parserState->parserLog;
if (logger)
*logger = parserState->logger;
return parserState->deck;
}
DeckPtr Parser::parseString(const std::string &data, ParserLogPtr parserLog) const {
DeckPtr Parser::parseString(const std::string &data, LoggerPtr logger) const {
std::shared_ptr<ParserState> parserState(new ParserState(data, DeckPtr(new Deck())));
parseState(parserState);
applyUnitsToDeck(parserState->deck);
if (parserLog)
*parserLog = parserState->parserLog;
if (logger)
*logger = parserState->logger;
return parserState->deck;
}
DeckPtr Parser::parseStream(std::shared_ptr<std::istream> inputStream, ParserLogPtr parserLog) const {
DeckPtr Parser::parseStream(std::shared_ptr<std::istream> inputStream, LoggerPtr logger) const {
std::shared_ptr<ParserState> parserState(new ParserState(inputStream, DeckPtr(new Deck())));
parseState(parserState);
applyUnitsToDeck(parserState->deck);
if (parserLog)
*parserLog = parserState->parserLog;
if (logger)
*logger = parserState->logger;
return parserState->deck;
}
@ -296,15 +297,15 @@ namespace Opm {
deckKeyword->setParserKeyword(parserKeyword);
parserState->deck->addKeyword(deckKeyword);
} else if (action == IGNORE_WARNING)
parserState->parserLog.addWarning(parserState->dataFile.string(),
parserState->rawKeyword->getLineNR(),
"The keyword " + parserState->rawKeyword->getKeywordName() + " is ignored - this might potentially affect the results");
parserState->logger.addWarning(parserState->dataFile.string(),
parserState->rawKeyword->getLineNR(),
"The keyword " + parserState->rawKeyword->getKeywordName() + " is ignored - this might potentially affect the results");
} else {
DeckKeywordPtr deckKeyword(new DeckKeyword(parserState->rawKeyword->getKeywordName(), false));
deckKeyword->setLocation(parserState->rawKeyword->getFilename(),
parserState->rawKeyword->getLineNR());
parserState->deck->addKeyword(deckKeyword);
parserState->parserLog.addWarning(parserState->dataFile.string(),
parserState->logger.addWarning(parserState->dataFile.string(),
parserState->rawKeyword->getLineNR(),
"The keyword " + parserState->rawKeyword->getKeywordName() + " is not recognized");
}

9
opm/parser/eclipse/Parser/Parser.hpp
View File

@ -29,10 +29,11 @@
#include <opm/json/JsonObject.hpp>
#include <opm/parser/eclipse/Log/Logger.hpp>
#include <opm/parser/eclipse/RawDeck/RawKeyword.hpp>
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/Parser/ParserKeyword.hpp>
#include <opm/parser/eclipse/Parser/ParserLog.hpp>
namespace Opm {
@ -47,9 +48,9 @@ namespace Opm {
Parser(bool addDefault = true);
/// The starting point of the parsing process. The supplied file is parsed, and the resulting Deck is returned.
DeckPtr parseFile(const std::string &dataFile, ParserLogPtr parserLog = std::make_shared<ParserLog>(&std::cout)) const;
DeckPtr parseString(const std::string &data, ParserLogPtr parserLog = std::make_shared<ParserLog>(&std::cout)) const;
DeckPtr parseStream(std::shared_ptr<std::istream> inputStream, ParserLogPtr parserLog = std::make_shared<ParserLog>(&std::cout)) const;
DeckPtr parseFile(const std::string &dataFile, LoggerPtr logger = std::make_shared<Logger>(&std::cout)) const;
DeckPtr parseString(const std::string &data, LoggerPtr logger = std::make_shared<Logger>(&std::cout)) const;
DeckPtr parseStream(std::shared_ptr<std::istream> inputStream, LoggerPtr logger = std::make_shared<Logger>(&std::cout)) const;
/// Method to add ParserKeyword instances, these holding type and size information about the keywords and their data.
void addParserKeyword(ParserKeywordConstPtr parserKeyword);