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

Merge remote-tracking branch 'upstream/master' into closed_completions

Browse Source
This commit is contained in:
Fredrik Gundersen
2015-01-13 12:57:46 +01:00
parent e8aac2120c cdf576d5f1
commit 1a669d1c87
100 changed files with 2332 additions and 828 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
opm/json/CMakeLists.txt
View File

@@ -14,4 +14,6 @@ foreach ( header ${json_headers} )
install( FILES ${header} DESTINATION ${CMAKE_INSTALL_PREFIX}/include/opm/json RENAME ${header})
endforeach()
add_subdirectory( tests )
if (BUILD_TESTING)
add_subdirectory( tests )
endif()

2
opm/parser/eclipse/Applications/Schedule.cpp
View File

@@ -14,7 +14,7 @@
int main(int /* argc */, char** argv) {
Opm::ParserPtr parser(new Opm::Parser());
std::string file = argv[1];
Opm::DeckConstPtr deck = parser->parseFile(file, false);
Opm::DeckConstPtr deck = parser->parseFile(file);
Opm::Schedule sched( deck );
std::cout << "Wells: " << sched.numWells() << std::endl;

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

@@ -18,12 +18,14 @@
*/
#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>
#include <opm/parser/eclipse/EclipseState/EclipseState.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 +40,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 +68,11 @@ 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, true, parserLog);
Opm::LoggerPtr logger(new Opm::Logger);
Opm::DeckConstPtr deck = parser->parseFile(file, logger);
Opm::EclipseState state(deck);
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})

21
opm/parser/eclipse/Deck/DeckDoubleItem.cpp
View File

@@ -72,6 +72,9 @@ namespace Opm {
void DeckDoubleItem::push_back(std::deque<double> data , size_t items) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
for (size_t i=0; i<items; i++) {
m_data.push_back(data[i]);
m_dataPointDefaulted.push_back(false);
@@ -80,16 +83,25 @@ namespace Opm {
void DeckDoubleItem::push_back(std::deque<double> data) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
push_back( data , data.size() );
m_dataPointDefaulted.push_back(false);
}
void DeckDoubleItem::push_back(double data) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
m_data.push_back( data );
m_dataPointDefaulted.push_back(false);
}
void DeckDoubleItem::push_backMultiple(double value, size_t numValues) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
for (size_t i = 0; i < numValues; i++) {
m_data.push_back( value );
m_dataPointDefaulted.push_back(false);
@@ -98,10 +110,19 @@ namespace Opm {
void DeckDoubleItem::push_backDefault(double data) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
m_data.push_back( data );
m_dataPointDefaulted.push_back(true);
}
void DeckDoubleItem::push_backDummyDefault() {
if (m_dataPointDefaulted.size() != 0)
throw std::logic_error("Pseudo defaults can only be specified for empty items");
m_dataPointDefaulted.push_back(true);
}
size_t DeckDoubleItem::size() const {
return m_data.size();

2
opm/parser/eclipse/Deck/DeckDoubleItem.hpp
View File

@@ -42,6 +42,8 @@ namespace Opm {
void push_back(std::deque<double> data);
void push_back(double value);
void push_backDefault(double value);
// trying to access the data of a "dummy default item" will raise an exception
void push_backDummyDefault();
void push_backMultiple(double value, size_t numValues);
void push_backDimension(std::shared_ptr<const Dimension> activeDimension , std::shared_ptr<const Dimension> defaultDimension);

22
opm/parser/eclipse/Deck/DeckFloatItem.cpp
View File

@@ -69,6 +69,9 @@ namespace Opm {
}
void DeckFloatItem::push_back(std::deque<float> data , size_t items) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
for (size_t i=0; i<items; i++) {
m_data.push_back(data[i]);
m_dataPointDefaulted.push_back(false);
@@ -76,11 +79,17 @@ namespace Opm {
}
void DeckFloatItem::push_back(std::deque<float> data) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
push_back( data , data.size() );
m_dataPointDefaulted.push_back(false);
}
void DeckFloatItem::push_back(float data) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
m_data.push_back( data );
m_dataPointDefaulted.push_back(false);
}
@@ -88,6 +97,9 @@ namespace Opm {
void DeckFloatItem::push_backMultiple(float value, size_t numValues) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
for (size_t i = 0; i < numValues; i++) {
m_data.push_back( value );
m_dataPointDefaulted.push_back(false);
@@ -96,10 +108,20 @@ namespace Opm {
void DeckFloatItem::push_backDefault(float data) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
m_data.push_back( data );
m_dataPointDefaulted.push_back(true);
}
void DeckFloatItem::push_backDummyDefault() {
if (m_dataPointDefaulted.size() != 0)
throw std::logic_error("Pseudo defaults can only be specified for empty items");
m_dataPointDefaulted.push_back(true);
}
void DeckFloatItem::push_backDimension(std::shared_ptr<const Dimension> activeDimension , std::shared_ptr<const Dimension> defaultDimension) {
if (m_dataPointDefaulted.empty() || m_dataPointDefaulted.back())

2
opm/parser/eclipse/Deck/DeckFloatItem.hpp
View File

@@ -41,6 +41,8 @@ namespace Opm {
void push_back(std::deque<float> data);
void push_back(float value);
void push_backDefault(float value);
// trying to access the data of a "dummy default item" will raise an exception
void push_backDummyDefault();
void push_backMultiple(float value, size_t numValues);
void push_backDimension(std::shared_ptr<const Dimension> activeDimension , std::shared_ptr<const Dimension> defaultDimension);

22
opm/parser/eclipse/Deck/DeckIntItem.cpp
View File

@@ -35,6 +35,9 @@ namespace Opm {
}
void DeckIntItem::push_back(std::deque<int> data, size_t items) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
for (size_t i = 0; i < items; i++) {
m_data.push_back(data[i]);
m_dataPointDefaulted.push_back(false);
@@ -42,21 +45,40 @@ namespace Opm {
}
void DeckIntItem::push_back(std::deque<int> data) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
push_back(data, data.size());
m_dataPointDefaulted.push_back(false);
}
void DeckIntItem::push_back(int data) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
m_data.push_back(data);
m_dataPointDefaulted.push_back(false);
}
void DeckIntItem::push_backDefault(int data) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
m_data.push_back( data );
m_dataPointDefaulted.push_back(true);
}
void DeckIntItem::push_backDummyDefault() {
if (m_dataPointDefaulted.size() != 0)
throw std::logic_error("Pseudo defaults can only be specified for empty items");
m_dataPointDefaulted.push_back(true);
}
void DeckIntItem::push_backMultiple(int value, size_t numValues) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
for (size_t i = 0; i < numValues; i++) {
m_data.push_back( value );
m_dataPointDefaulted.push_back(false);

2
opm/parser/eclipse/Deck/DeckIntItem.hpp
View File

@@ -38,6 +38,8 @@ namespace Opm {
void push_back(std::deque<int> data , size_t items);
void push_back(std::deque<int> data);
void push_back(int value);
// trying to access the data of a "dummy default item" will raise an exception
void push_backDummyDefault();
void push_backMultiple(int value , size_t numValues);
void push_backDefault(int value);

15
opm/parser/eclipse/Deck/DeckItem.cpp
View File

@@ -36,8 +36,11 @@ namespace Opm {
}
bool DeckItem::defaultApplied(size_t index) const {
assert(m_dataPointDefaulted.size() == size());
assertSize(index);
if (index >= m_dataPointDefaulted.size())
throw std::out_of_range("Index must be smaller than "
+ boost::lexical_cast<std::string>(m_dataPointDefaulted.size())
+ " but is "
+ boost::lexical_cast<std::string>(index));
return m_dataPointDefaulted[index];
}
@@ -51,4 +54,12 @@ namespace Opm {
}
bool DeckItem::hasValue(size_t index) const {
if (index < size())
return true;
else
return false;
}
}

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

@@ -36,6 +36,11 @@ namespace Opm {
// return true if the default value was used for a given data point
bool defaultApplied(size_t index) const;
// Return true if the item has a value for the current index;
// does not differentiate between default values from the
// config and values which have been set in the deck.
bool hasValue(size_t index) const;
// if the number returned by this method is less than what is semantically
// expected (e.g. size() is less than the number of cells in the grid for
// keywords like e.g. SGL), then the remaining values are defaulted. The deck

20
opm/parser/eclipse/Deck/DeckStringItem.cpp
View File

@@ -45,6 +45,9 @@ namespace Opm {
void DeckStringItem::push_back(std::deque<std::string> data, size_t items) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
for (size_t i=0; i<items; i++) {
m_data.push_back(data[i]);
m_dataPointDefaulted.push_back(false);
@@ -53,12 +56,18 @@ namespace Opm {
void DeckStringItem::push_back(std::deque<std::string> data) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
push_back(data, data.size());
m_dataPointDefaulted.push_back(false);
}
void DeckStringItem::push_back(const std::string& data ) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
m_data.push_back( data );
m_dataPointDefaulted.push_back(false);
}
@@ -66,6 +75,9 @@ namespace Opm {
void DeckStringItem::push_backMultiple(std::string value, size_t numValues) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
for (size_t i = 0; i < numValues; i++) {
m_data.push_back( value );
m_dataPointDefaulted.push_back(false);
@@ -74,11 +86,19 @@ namespace Opm {
void DeckStringItem::push_backDefault(std::string data) {
if (m_dataPointDefaulted.size() != m_data.size())
throw std::logic_error("To add a value to an item, no \"pseudo defaults\" can be added before");
m_data.push_back( data );
m_dataPointDefaulted.push_back(true);
}
void DeckStringItem::push_backDummyDefault() {
if (m_dataPointDefaulted.size() != 0)
throw std::logic_error("Pseudo defaults can only be specified for empty items");
m_dataPointDefaulted.push_back(true);
}
size_t DeckStringItem::size() const {
return m_data.size();

2
opm/parser/eclipse/Deck/DeckStringItem.hpp
View File

@@ -42,6 +42,8 @@ namespace Opm {
void push_back(std::deque<std::string> data);
void push_back(const std::string& value);
void push_backDefault(std::string value);
// trying to access the data of a "dummy default item" will raise an exception
void push_backDummyDefault();
void push_backMultiple(std::string value, size_t numItems);
size_t size() const;

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:

8
opm/parser/eclipse/Deck/tests/DeckDoubleItemTests.cpp
View File

@@ -100,7 +100,15 @@ BOOST_AUTO_TEST_CASE(SetInDeck) {
BOOST_CHECK_EQUAL( true , deckDoubleItem.defaultApplied(2) );
}
BOOST_AUTO_TEST_CASE(DummyDefaults) {
DeckDoubleItem deckDoubleItem("TEST");
BOOST_CHECK_EQUAL(deckDoubleItem.size(), 0);
deckDoubleItem.push_backDummyDefault();
BOOST_CHECK_EQUAL(deckDoubleItem.size(), 0);
BOOST_CHECK_EQUAL(true, deckDoubleItem.defaultApplied(0));
BOOST_CHECK_THROW(deckDoubleItem.getRawDouble(0), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(PushBackMultiple) {
DeckDoubleItem item("HEI");

10
opm/parser/eclipse/Deck/tests/DeckFloatItemTests.cpp
View File

@@ -34,6 +34,16 @@ BOOST_AUTO_TEST_CASE(InitializeFloat) {
BOOST_REQUIRE_NO_THROW(DeckFloatItem deckFloatItem("TEST"));
}
BOOST_AUTO_TEST_CASE(DummyDefaults) {
DeckFloatItem deckFloatItem("TEST");
BOOST_CHECK_EQUAL(deckFloatItem.size(), 0);
deckFloatItem.push_backDummyDefault();
BOOST_CHECK_EQUAL(deckFloatItem.size(), 0);
BOOST_CHECK_EQUAL(true, deckFloatItem.defaultApplied(0));
BOOST_CHECK_THROW(deckFloatItem.getRawFloat(0), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(GetFloatAtIndex_NoData_ExceptionThrown) {
DeckFloatItem deckFloatItem("TEST");

24
opm/parser/eclipse/Deck/tests/DeckIntItemTests.cpp
View File

@@ -30,6 +30,30 @@ BOOST_AUTO_TEST_CASE(Initialize) {
BOOST_REQUIRE_NO_THROW(DeckIntItem deckIntItem("TEST"));
}
BOOST_AUTO_TEST_CASE(HasValue) {
DeckIntItem deckIntItem("TEST");
BOOST_CHECK_EQUAL( false , deckIntItem.hasValue(0) );
deckIntItem.push_back(1);
BOOST_CHECK_EQUAL( true , deckIntItem.hasValue(0) );
BOOST_CHECK_EQUAL( false , deckIntItem.hasValue(1) );
}
BOOST_AUTO_TEST_CASE(DummyDefaults) {
DeckIntItem deckIntItem("TEST");
BOOST_CHECK_EQUAL(deckIntItem.size(), 0);
deckIntItem.push_backDummyDefault();
BOOST_CHECK_EQUAL(deckIntItem.size(), 0);
BOOST_CHECK_EQUAL(true, deckIntItem.defaultApplied(0));
BOOST_CHECK_EQUAL( false , deckIntItem.hasValue(0));
BOOST_CHECK_EQUAL( false , deckIntItem.hasValue(1));
BOOST_CHECK_THROW(deckIntItem.getInt(0), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(GetIntAtIndex_NoData_ExceptionThrown) {
DeckIntItem deckIntItem("TEST");
deckIntItem.push_back(100);

10
opm/parser/eclipse/Deck/tests/DeckStringItemTests.cpp
View File

@@ -31,6 +31,16 @@ BOOST_AUTO_TEST_CASE(InitializeString) {
BOOST_CHECK_EQUAL("TEST", stringItem.name());
}
BOOST_AUTO_TEST_CASE(DummyDefaults) {
DeckStringItem deckStringItem("TEST");
BOOST_CHECK_EQUAL(deckStringItem.size(), 0);
deckStringItem.push_backDummyDefault();
BOOST_CHECK_EQUAL(deckStringItem.size(), 0);
BOOST_CHECK_EQUAL(true, deckStringItem.defaultApplied(0));
BOOST_CHECK_THROW(deckStringItem.getString(0), std::out_of_range);
}
BOOST_AUTO_TEST_CASE(GetStringAtIndex_NoData_ExceptionThrown) {
DeckStringItem deckStringItem("TEST");
BOOST_CHECK_THROW(deckStringItem.getString(0), std::out_of_range);

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));
}

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

@@ -17,20 +17,21 @@
along with OPM. If not, see <http://www.gnu.org/licenses/>.
*/
#include <iostream>
#include <sstream>
#include <math.h>
#include <boost/algorithm/string/join.hpp>
#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>
#include <boost/algorithm/string/join.hpp>
namespace Opm {
@@ -110,21 +111,31 @@ namespace Opm {
}
EclipseState::EclipseState(DeckConstPtr deck, ParserLogPtr parserLog)
static bool isInt(double value) {
double diff = fabs(nearbyint(value) - value);
if (diff < 1e-6)
return true;
else
return false;
}
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 +247,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 +276,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 +308,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 +342,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 +354,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 +369,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 +385,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 +401,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 +409,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 +419,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 +512,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 +526,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" ),
@@ -699,6 +710,13 @@ namespace Opm {
SupportedDoubleKeywordInfo( "PERMXZ", nan, distributeTopLayer , "Permeability" ), // E300 only
SupportedDoubleKeywordInfo( "PERMYZ", nan, distributeTopLayer , "Permeability" ), // E300 only
// the transmissibility keywords for neighboring
// conections. note that these keywords don't seem to
// require a post-processor...
SupportedDoubleKeywordInfo( "TRANX", nan, "Transmissibility" ),
SupportedDoubleKeywordInfo( "TRANY", nan, "Transmissibility" ),
SupportedDoubleKeywordInfo( "TRANZ", nan, "Transmissibility" ),
// gross-to-net thickness (acts as a multiplier for PORO
// and the permeabilities in the X-Y plane as well as for
// the well rates.)
@@ -724,8 +742,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
@@ -733,62 +751,74 @@ 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() == "EQUALREG")
handleEQUALREGKeyword(deckKeyword , logger , enabledTypes);
if (deckKeyword->name() == "ADDREG")
handleADDREGKeyword(deckKeyword , logger , enabledTypes);
if (deckKeyword->name() == "MULTIREG")
handleMULTIREGKeyword(deckKeyword , logger , enabledTypes);
if (deckKeyword->name() == "COPYREG")
handleCOPYREGKeyword(deckKeyword , logger , enabledTypes);
if (deckKeyword->name() == "MULTIPLY")
handleMULTIPLYKeyword(deckKeyword, parserLog, boxManager, enabledTypes);
handleMULTIPLYKeyword(deckKeyword, logger, boxManager, enabledTypes);
boxManager.endKeyword();
}
@@ -799,7 +829,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;
@@ -817,13 +847,190 @@ namespace Opm {
}
void EclipseState::handleMULTIPLYKeyword(DeckKeywordConstPtr deckKeyword, ParserLogPtr parserLog, BoxManager& boxManager, int enabledTypes) {
void EclipseState::handleEQUALREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr , int enabledTypes) {
EclipseGridConstPtr grid = getEclipseGrid();
for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
const std::string& targetArray = record->getItem("ARRAY")->getString(0);
if (!supportsGridProperty( targetArray , IntProperties + DoubleProperties))
throw std::invalid_argument("Fatal error processing EQUALREG keyword - invalid/undefined keyword: " + targetArray);
if (supportsGridProperty( targetArray , enabledTypes)) {
double doubleValue = record->getItem("VALUE")->getRawDouble(0);
int regionValue = record->getItem("REGION_NUMBER")->getInt(0);
const std::string regionArray = MULTREGT::RegionNameFromDeckValue( record->getItem("REGION_NAME")->getString(0) );
std::shared_ptr<Opm::GridProperty<int> > regionProperty = m_intGridProperties->getInitializedKeyword(regionArray);
std::vector<bool> mask;
regionProperty->initMask( regionValue , mask);
if (m_intGridProperties->supportsKeyword( targetArray )) {
if (enabledTypes & IntProperties) {
if (isInt( doubleValue )) {
std::shared_ptr<Opm::GridProperty<int> > targetProperty = m_intGridProperties->getKeyword(targetArray);
int intValue = static_cast<int>( doubleValue + 0.5 );
targetProperty->maskedSet( intValue , mask);
} else
throw std::invalid_argument("Fatal error processing EQUALREG keyword - expected integer value for: " + targetArray);
}
}
else if (m_doubleGridProperties->supportsKeyword( targetArray )) {
if (enabledTypes & DoubleProperties) {
std::shared_ptr<Opm::GridProperty<double> > targetProperty = m_doubleGridProperties->getKeyword(targetArray);
const std::string& dimensionString = targetProperty->getDimensionString();
double SIValue = doubleValue * getSIScaling( dimensionString );
targetProperty->maskedSet( SIValue , mask);
}
}
else {
throw std::invalid_argument("Fatal error processing EQUALREG keyword - invalid/undefined keyword: " + targetArray);
}
}
}
}
void EclipseState::handleADDREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr , int enabledTypes) {
EclipseGridConstPtr grid = getEclipseGrid();
for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
const std::string& targetArray = record->getItem("ARRAY")->getString(0);
if (!supportsGridProperty( targetArray , IntProperties + DoubleProperties))
throw std::invalid_argument("Fatal error processing ADDREG keyword - invalid/undefined keyword: " + targetArray);
if (supportsGridProperty( targetArray , enabledTypes)) {
double doubleValue = record->getItem("SHIFT")->getRawDouble(0);
int regionValue = record->getItem("REGION_NUMBER")->getInt(0);
const std::string regionArray = MULTREGT::RegionNameFromDeckValue( record->getItem("REGION_NAME")->getString(0) );
std::shared_ptr<Opm::GridProperty<int> > regionProperty = m_intGridProperties->getInitializedKeyword(regionArray);
std::vector<bool> mask;
regionProperty->initMask( regionValue , mask);
if (m_intGridProperties->hasKeyword( targetArray )) {
if (enabledTypes & IntProperties) {
if (isInt( doubleValue )) {
std::shared_ptr<Opm::GridProperty<int> > targetProperty = m_intGridProperties->getKeyword(targetArray);
int intValue = static_cast<int>( doubleValue + 0.5 );
targetProperty->maskedAdd( intValue , mask);
} else
throw std::invalid_argument("Fatal error processing ADDREG keyword - expected integer value for: " + targetArray);
}
}
else if (m_doubleGridProperties->hasKeyword( targetArray )) {
if (enabledTypes & DoubleProperties) {
std::shared_ptr<Opm::GridProperty<double> > targetProperty = m_doubleGridProperties->getKeyword(targetArray);
const std::string& dimensionString = targetProperty->getDimensionString();
double SIValue = doubleValue * getSIScaling( dimensionString );
targetProperty->maskedAdd( SIValue , mask);
}
}
else {
throw std::invalid_argument("Fatal error processing ADDREG keyword - invalid/undefined keyword: " + targetArray);
}
}
}
}
void EclipseState::handleMULTIREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr , int enabledTypes) {
EclipseGridConstPtr grid = getEclipseGrid();
for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
const std::string& targetArray = record->getItem("ARRAY")->getString(0);
if (!supportsGridProperty( targetArray , IntProperties + DoubleProperties))
throw std::invalid_argument("Fatal error processing MULTIREG keyword - invalid/undefined keyword: " + targetArray);
if (supportsGridProperty( targetArray , enabledTypes)) {
double doubleValue = record->getItem("FACTOR")->getRawDouble(0);
int regionValue = record->getItem("REGION_NUMBER")->getInt(0);
const std::string regionArray = MULTREGT::RegionNameFromDeckValue( record->getItem("REGION_NAME")->getString(0) );
std::shared_ptr<Opm::GridProperty<int> > regionProperty = m_intGridProperties->getInitializedKeyword( regionArray );
std::vector<bool> mask;
regionProperty->initMask( regionValue , mask);
if (m_intGridProperties->hasKeyword( targetArray )) {
if (enabledTypes & IntProperties) {
if (isInt( doubleValue )) {
std::shared_ptr<Opm::GridProperty<int> > targetProperty = m_intGridProperties->getKeyword( targetArray );
int intValue = static_cast<int>( doubleValue + 0.5 );
targetProperty->maskedMultiply( intValue , mask);
} else
throw std::invalid_argument("Fatal error processing MULTIREG keyword - expected integer value for: " + targetArray);
}
}
else if (m_doubleGridProperties->hasKeyword( targetArray )) {
if (enabledTypes & DoubleProperties) {
std::shared_ptr<Opm::GridProperty<double> > targetProperty = m_doubleGridProperties->getKeyword(targetArray);
targetProperty->maskedMultiply( doubleValue , mask);
}
}
else {
throw std::invalid_argument("Fatal error processing MULTIREG keyword - invalid/undefined keyword: " + targetArray);
}
}
}
}
void EclipseState::handleCOPYREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr , int enabledTypes) {
EclipseGridConstPtr grid = getEclipseGrid();
for (size_t recordIdx = 0; recordIdx < deckKeyword->size(); ++recordIdx) {
DeckRecordConstPtr record = deckKeyword->getRecord(recordIdx);
const std::string& srcArray = record->getItem("ARRAY")->getString(0);
const std::string& targetArray = record->getItem("TARGET_ARRAY")->getString(0);
if (!supportsGridProperty( targetArray , IntProperties + DoubleProperties))
throw std::invalid_argument("Fatal error processing MULTIREG keyword - invalid/undefined keyword: " + targetArray);
if (!supportsGridProperty( srcArray , IntProperties + DoubleProperties))
throw std::invalid_argument("Fatal error processing MULTIREG keyword - invalid/undefined keyword: " + srcArray);
if (supportsGridProperty( srcArray , enabledTypes)) {
int regionValue = record->getItem("REGION_NUMBER")->getInt(0);
const std::string regionArray = MULTREGT::RegionNameFromDeckValue( record->getItem("REGION_NAME")->getString(0) );
std::shared_ptr<Opm::GridProperty<int> > regionProperty = m_intGridProperties->getInitializedKeyword( regionArray );
std::vector<bool> mask;
regionProperty->initMask( regionValue , mask );
if (m_intGridProperties->hasKeyword( srcArray )) {
std::shared_ptr<Opm::GridProperty<int> > srcProperty = m_intGridProperties->getInitializedKeyword( srcArray );
if (supportsGridProperty( targetArray , IntProperties)) {
std::shared_ptr<Opm::GridProperty<int> > targetProperty = m_intGridProperties->getKeyword( targetArray );
targetProperty->maskedCopy( *srcProperty , mask );
} else
throw std::invalid_argument("Fatal error processing COPYREG keyword.");
} else if (m_doubleGridProperties->hasKeyword( srcArray )) {
std::shared_ptr<Opm::GridProperty<double> > srcProperty = m_doubleGridProperties->getInitializedKeyword( srcArray );
if (supportsGridProperty( targetArray , DoubleProperties)) {
std::shared_ptr<Opm::GridProperty<double> > targetProperty = m_doubleGridProperties->getKeyword( targetArray );
targetProperty->maskedCopy( *srcProperty , mask );
}
}
else {
throw std::invalid_argument("Fatal error processing COPYREG keyword - invalid/undefined keyword: " + targetArray);
}
}
}
}
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) {
@@ -849,13 +1056,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) {
@@ -868,7 +1075,7 @@ namespace Opm {
if (enabledTypes & DoubleProperties) {
std::shared_ptr<GridProperty<double> > property = m_doubleGridProperties->getKeyword( field );
double siShiftValue = shiftValue * getSIScaling(property->getKeywordInfo().getDimensionString());
double siShiftValue = shiftValue * getSIScaling(property->getDimensionString());
property->add(siShiftValue , boxManager.getActiveBox() );
}
} else if (!m_intGridProperties->supportsKeyword(field) &&
@@ -879,13 +1086,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) {
@@ -910,13 +1117,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)
@@ -950,7 +1157,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");
@@ -988,17 +1195,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");
}

61
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,33 @@ 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 handleEQUALREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, int enabledTypes);
void handleMULTIREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, int enabledTypes);
void handleADDREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, int enabledTypes);
void handleCOPYREGKeyword(DeckKeywordConstPtr deckKeyword, LoggerPtr logger, int enabledTypes);
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);

13
opm/parser/eclipse/EclipseState/Grid/GridProperties.hpp
View File

@@ -76,6 +76,19 @@ public:
return m_properties.at( keyword );
}
std::shared_ptr<GridProperty<T> > getInitializedKeyword(const std::string& keyword) {
if (hasKeyword(keyword))
return m_properties.at( keyword );
else {
if (supportsKeyword(keyword))
throw std::invalid_argument("Keyword: " + keyword + " is supported - but not initialized.");
else
throw std::invalid_argument("Keyword: " + keyword + " is not supported.");
}
}
bool addKeyword(const std::string& keywordName) {
if (!supportsKeyword( keywordName ))
throw std::invalid_argument("The keyword: " + keywordName + " is not supported in this container");

15
opm/parser/eclipse/EclipseState/Grid/GridProperty.cpp
View File

@@ -33,12 +33,13 @@ void GridProperty<double>::setDataPoint(size_t sourceIdx, size_t targetIdx, Opm:
}
template<>
bool GridProperty<int>::containsNaN( ) {
bool GridProperty<int>::containsNaN( ) const {
throw std::logic_error("Only <double> and can be meaningfully queried for nan");
}
template<>
bool GridProperty<double>::containsNaN( ) {
bool GridProperty<double>::containsNaN( ) const {
bool return_value = false;
size_t size = m_data.size();
size_t index = 0;
@@ -54,6 +55,16 @@ bool GridProperty<double>::containsNaN( ) {
}
return return_value;
}
template<>
const std::string& GridProperty<int>::getDimensionString() const {
throw std::logic_error("Only <double> grid properties have dimension");
}
template<>
const std::string& GridProperty<double>::getDimensionString() const {
return m_kwInfo.getDimensionString();
}
}

52
opm/parser/eclipse/EclipseState/Grid/GridProperty.hpp
View File

@@ -205,7 +205,9 @@ public:
iset(g,value);
}
bool containsNaN();
bool containsNaN() const;
const std::string& getDimensionString() const;
void multiplyWith(const GridProperty<T>& other) {
if ((m_nx == other.m_nx) && (m_ny == other.m_ny) && (m_nz == other.m_nz)) {
@@ -224,6 +226,52 @@ public:
return m_data;
}
void maskedSet(T value, const std::vector<bool>& mask) {
for (size_t g = 0; g < getCartesianSize(); g++) {
if (mask[g])
m_data[g] = value;
}
}
void maskedMultiply(T value, const std::vector<bool>& mask) {
for (size_t g = 0; g < getCartesianSize(); g++) {
if (mask[g])
m_data[g] *= value;
}
}
void maskedAdd(T value, const std::vector<bool>& mask) {
for (size_t g = 0; g < getCartesianSize(); g++) {
if (mask[g])
m_data[g] += value;
}
}
void maskedCopy(const GridProperty<T>& other, const std::vector<bool>& mask) {
for (size_t g = 0; g < getCartesianSize(); g++) {
if (mask[g])
m_data[g] = other.m_data[g];
}
}
void initMask(T value, std::vector<bool>& mask) {
mask.resize(getCartesianSize());
for (size_t g = 0; g < getCartesianSize(); g++) {
if (m_data[g] == value)
mask[g] = true;
else
mask[g] = false;
}
}
/**
Due to the convention where it is only neceassary to supply the
top layer of the petrophysical properties we can unfortunately
@@ -352,8 +400,6 @@ public:
}
private:
Opm::DeckItemConstPtr getDeckItem(Opm::DeckKeywordConstPtr deckKeyword) {
if (deckKeyword->size() != 1)

271
opm/parser/eclipse/EclipseState/Grid/tests/ADDREGTests.cpp Normal file
View File

@@ -0,0 +1,271 @@
/*
Copyright 2014 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 <stdexcept>
#include <iostream>
#include <boost/filesystem.hpp>
#include <cstdio>
#define BOOST_TEST_MODULE EqualRegTests
#include <boost/test/unit_test.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <opm/parser/eclipse/Units/ConversionFactors.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/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
static Opm::DeckPtr createDeckInvalidArray() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"ADDREG\n"
" MISSING 10 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckInvalidRegion() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"ADDREG\n"
" MISSING 10 10 MX / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckInvalidValue() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"MULTNUM \n"
" 1000*1 /\n"
"ADDREG\n"
" SATNUM 0.2 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckUnInitializedRegion() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"SATNUM \n"
" 1000*1 /\n"
"REGIONS\n"
"ADDREG\n"
" SATNUM 2 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckUnInitializedVector() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"MULTNUM \n"
" 1000*1 /\n"
"REGIONS\n"
"ADDREG\n"
" SATNUM 2 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createValidIntDeck() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 5 5 1 /\n"
"GRID\n"
"MULTNUM \n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"/\n"
"SATNUM\n"
" 25*1 \n"
"/\n"
"ADDREG\n"
" SATNUM 11 1 M / \n"
" SATNUM 20 2 / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createValidPERMXDeck() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 5 5 1 /\n"
"GRID\n"
"MULTNUM \n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"/\n"
"BOX\n"
" 1 2 1 5 1 1 / \n"
"PERMZ\n"
" 10*1 /\n"
"ENDBOX\n"
"BOX\n"
" 3 5 1 5 1 1 / \n"
"PERMZ\n"
" 15*2 /\n"
"ENDBOX\n"
"PERMX\n"
"25*1 /\n"
"ADDREG\n"
" PERMX 1 1 / \n"
" PERMX 2 2 / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
BOOST_AUTO_TEST_CASE(InvalidArrayThrows) {
Opm::DeckPtr deck = createDeckInvalidArray();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(InvalidRegionThrows) {
Opm::DeckPtr deck = createDeckInvalidRegion();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(ExpectedIntThrows) {
Opm::DeckPtr deck = createDeckInvalidValue();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(UnInitializedRegionThrows) {
Opm::DeckPtr deck = createDeckUnInitializedRegion();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(UnInitializedVectorThrows) {
Opm::DeckPtr deck = createDeckUnInitializedVector();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(IntSetCorrectly) {
Opm::DeckPtr deck = createValidIntDeck();
Opm::EclipseState state(deck);
std::shared_ptr<Opm::GridProperty<int> > property = state.getIntGridProperty( "SATNUM");
for (size_t j=0; j< 5; j++)
for (size_t i = 0; i < 5; i++) {
if (i < 2)
BOOST_CHECK_EQUAL( 12 , property->iget(i,j,0));
else
BOOST_CHECK_EQUAL( 21 , property->iget(i,j,0));
}
}
BOOST_AUTO_TEST_CASE(UnitAppliedCorrectly) {
Opm::DeckPtr deck = createValidPERMXDeck();
Opm::EclipseState state(deck);
/*std::shared_ptr<Opm::GridProperty<double> > permz = state.getDoubleGridProperty( "PERMZ");
for (size_t j=0; j< 5; j++)
for (size_t i = 0; i < 5; i++) {
if (i < 2)
BOOST_CHECK_EQUAL( 2 * Opm::Metric::Permeability , permz->iget(i,j,0));
else
BOOST_CHECK_EQUAL( 4 * Opm::Metric::Permeability , permz->iget(i,j,0));
}
*/
}

17
opm/parser/eclipse/EclipseState/Grid/tests/CMakeLists.txt
View File

@@ -46,3 +46,20 @@ add_executable(runFaultTests FaultTests.cpp)
target_link_libraries(runFaultTests Parser ${Boost_LIBRARIES})
add_test(NAME runFaultTests WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} COMMAND ${TEST_MEMCHECK_TOOL} ${EXECUTABLE_OUTPUT_PATH}/runFaultTests )
add_executable(runEqualRegTests EqualRegTests.cpp)
target_link_libraries(runEqualRegTests Parser ${Boost_LIBRARIES})
add_test(NAME runEqualRegTests WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} COMMAND ${TEST_MEMCHECK_TOOL} ${EXECUTABLE_OUTPUT_PATH}/runEqualRegTests )
add_executable(runMultiRegTests MultiRegTests.cpp)
target_link_libraries(runMultiRegTests Parser ${Boost_LIBRARIES})
add_test(NAME runMultiRegTests WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} COMMAND ${TEST_MEMCHECK_TOOL} ${EXECUTABLE_OUTPUT_PATH}/runMultiRegTests )
add_executable(runADDREGTests ADDREGTests.cpp)
target_link_libraries(runADDREGTests Parser ${Boost_LIBRARIES})
add_test(NAME runADDREGTests WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} COMMAND ${TEST_MEMCHECK_TOOL} ${EXECUTABLE_OUTPUT_PATH}/runADDREGTests )
add_executable(runCopyRegTests CopyRegTests.cpp)
target_link_libraries(runCopyRegTests Parser ${Boost_LIBRARIES})
add_test(NAME runCopyRegTests WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} COMMAND ${TEST_MEMCHECK_TOOL} ${EXECUTABLE_OUTPUT_PATH}/runCopyRegTests )

219
opm/parser/eclipse/EclipseState/Grid/tests/CopyRegTests.cpp Normal file
View File

@@ -0,0 +1,219 @@
/*
Copyright 2014 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 <stdexcept>
#include <iostream>
#include <boost/filesystem.hpp>
#include <cstdio>
#define BOOST_TEST_MODULE EqualRegTests
#include <boost/test/unit_test.hpp>
#include <boost/date_time/posix_time/posix_time.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/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
static Opm::DeckPtr createDeckInvalidArray1() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"SATNUM\n"
" 1000*1 /\n"
"COPYREG\n"
" MISSING SATNUM 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckInvalidArray2() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"SATNUM\n"
" 1000*1 /\n"
"COPYREG\n"
" SATNUM MISSING 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckInvalidTypeMismatch() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"SATNUM\n"
" 1000*1 /\n"
"COPYREG\n"
" SATNUM PERMX 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckInvalidRegion() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"SATNUM\n"
" 1000*1 /\n"
"COPYREG\n"
" SATNUM FLUXNUM 10 MX / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckUnInitialized() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"REGIONS\n"
"COPYREG\n"
" SATNUM FLUXNUM 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createValidIntDeck() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 5 5 1 /\n"
"GRID\n"
"MULTNUM \n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"/\n"
"SATNUM\n"
" 25*10 /\n"
"FLUXNUM\n"
" 25*3 /\n"
"COPYREG\n"
" SATNUM FLUXNUM 1 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
BOOST_AUTO_TEST_CASE(InvalidArrayThrows1) {
Opm::DeckPtr deck = createDeckInvalidArray1();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(InvalidArrayThrows2) {
Opm::DeckPtr deck = createDeckInvalidArray2();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(InvalidRegionThrows) {
Opm::DeckPtr deck = createDeckInvalidRegion();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(UnInitializedVectorThrows) {
Opm::DeckPtr deck = createDeckUnInitialized();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(TypeMismatchThrows) {
Opm::DeckPtr deck = createDeckInvalidTypeMismatch();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(IntSetCorrectly) {
Opm::DeckPtr deck = createValidIntDeck();
Opm::EclipseState state(deck);
std::shared_ptr<Opm::GridProperty<int> > property = state.getIntGridProperty( "FLUXNUM");
for (size_t j=0; j< 5; j++)
for (size_t i = 0; i < 5; i++) {
if (i < 2)
BOOST_CHECK_EQUAL( 10 , property->iget(i,j,0));
else
BOOST_CHECK_EQUAL( 3 , property->iget(i,j,0));
}
}

230
opm/parser/eclipse/EclipseState/Grid/tests/EqualRegTests.cpp Normal file
View File

@@ -0,0 +1,230 @@
/*
Copyright 2014 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 <stdexcept>
#include <iostream>
#include <boost/filesystem.hpp>
#include <cstdio>
#define BOOST_TEST_MODULE EqualRegTests
#include <boost/test/unit_test.hpp>
#include <boost/date_time/posix_time/posix_time.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/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
static Opm::DeckPtr createDeckInvalidArray() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"EQUALREG\n"
" MISSING 10 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckInvalidRegion() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"EQUALREG\n"
" MISSING 10 10 MX / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckInvalidValue() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"EQUALREG\n"
" SATNUM 0.2 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckUnInitialized() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"REGIONS\n"
"EQUALREG\n"
" SATNUM 2 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createValidIntDeck() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 5 5 1 /\n"
"GRID\n"
"MULTNUM \n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"/\n"
"EQUALREG\n"
" SATNUM 11 1 M / \n"
" SATNUM 20 2 / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createValidPERMXDeck() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 5 5 1 /\n"
"GRID\n"
"MULTNUM \n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"/\n"
"BOX\n"
" 1 2 1 5 1 1 / \n"
"PERMZ\n"
" 10*1 /\n"
"ENDBOX\n"
"BOX\n"
" 3 5 1 5 1 1 / \n"
"PERMZ\n"
" 15*2 /\n"
"ENDBOX\n"
"EQUALREG\n"
" PERMX 1 1 / \n"
" PERMX 2 2 / \n"
"/\n"
"EQUALS\n"
" PERMY 1 1 2 1 5 1 1 / \n"
" PERMY 2 3 5 1 5 1 1 / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
BOOST_AUTO_TEST_CASE(InvalidArrayThrows) {
Opm::DeckPtr deck = createDeckInvalidArray();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(InvalidRegionThrows) {
Opm::DeckPtr deck = createDeckInvalidRegion();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(ExpectedIntThrows) {
Opm::DeckPtr deck = createDeckInvalidValue();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(UnInitializedVectorThrows) {
Opm::DeckPtr deck = createDeckUnInitialized();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(IntSetCorrectly) {
Opm::DeckPtr deck = createValidIntDeck();
Opm::EclipseState state(deck);
std::shared_ptr<Opm::GridProperty<int> > property = state.getIntGridProperty( "SATNUM");
for (size_t j=0; j< 5; j++)
for (size_t i = 0; i < 5; i++) {
if (i < 2)
BOOST_CHECK_EQUAL( 11 , property->iget(i,j,0));
else
BOOST_CHECK_EQUAL( 20 , property->iget(i,j,0));
}
}
BOOST_AUTO_TEST_CASE(UnitAppliedCorrectly) {
Opm::DeckPtr deck = createValidPERMXDeck();
Opm::EclipseState state(deck);
std::shared_ptr<Opm::GridProperty<double> > permx = state.getDoubleGridProperty( "PERMX");
std::shared_ptr<Opm::GridProperty<double> > permy = state.getDoubleGridProperty( "PERMY");
std::shared_ptr<Opm::GridProperty<double> > permz = state.getDoubleGridProperty( "PERMZ");
for (size_t g=0; g< 25; g++) {
BOOST_CHECK_EQUAL( permz->iget(g), permx->iget(g));
BOOST_CHECK_EQUAL( permy->iget(g), permx->iget(g));
}
}

3
opm/parser/eclipse/EclipseState/Grid/tests/GridPropertiesTests.cpp
View File

@@ -50,6 +50,9 @@ BOOST_AUTO_TEST_CASE(Empty) {
BOOST_CHECK( !gridProperties.supportsKeyword("FLUXNUM") );
BOOST_CHECK( !gridProperties.hasKeyword("SATNUM"));
BOOST_CHECK( !gridProperties.hasKeyword("FLUXNUM"));
BOOST_CHECK_THROW( gridProperties.getInitializedKeyword("SATNUM") , std::invalid_argument);
BOOST_CHECK_THROW( gridProperties.getInitializedKeyword("NONONO") , std::invalid_argument);
}

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

@@ -484,3 +484,20 @@ BOOST_AUTO_TEST_CASE(multiply) {
}
BOOST_AUTO_TEST_CASE(mask) {
typedef Opm::GridProperty<int>::SupportedKeywordInfo SupportedKeywordInfo;
SupportedKeywordInfo keywordInfo1("P" , 10 , "1");
SupportedKeywordInfo keywordInfo2("P" , 20 , "1");
Opm::GridProperty<int> p1( 5 , 5 , 4 , keywordInfo1);
Opm::GridProperty<int> p2( 5 , 5 , 4 , keywordInfo2);
std::vector<bool> mask;
p1.initMask(10 , mask);
p2.maskedSet( 10 , mask);
for (size_t g = 0; g < p1.getCartesianSize(); g++)
BOOST_CHECK_EQUAL( p1.iget(g) , p2.iget(g));
}

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 ));
}

221
opm/parser/eclipse/EclipseState/Grid/tests/MultiRegTests.cpp Normal file
View File

@@ -0,0 +1,221 @@
/*
Copyright 2014 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 <stdexcept>
#include <iostream>
#include <boost/filesystem.hpp>
#include <cstdio>
#define BOOST_TEST_MODULE MultiRegTests
#include <boost/test/unit_test.hpp>
#include <boost/date_time/posix_time/posix_time.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/Grid/EclipseGrid.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
static Opm::DeckPtr createDeckInvalidArray() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"MULTIREG\n"
" MISSING 10 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckInvalidRegion() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"REGIONS\n"
"SATNUM\n"
" 1000*1 /\n"
"MULTIREG\n"
" SATNUM 10 10 MX / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckInvalidValue() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"REGIONS\n"
"SATNUM\n"
" 1000*1 /\n"
"MULTIREG\n"
" SATNUM 0.2 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckMissingVector() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"REGIONS\n"
"SATNUM\n"
" 1000*1 /\n"
"MULTIREG\n"
" SATNUM 2 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createDeckUnInitialized() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 10 10 10 /\n"
"GRID\n"
"REGIONS\n"
"MULTIREG\n"
" SATNUM 2 10 M / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
static Opm::DeckPtr createValidIntDeck() {
const char *deckData =
"RUNSPEC\n"
"\n"
"DIMENS\n"
" 5 5 1 /\n"
"GRID\n"
"REGIONS\n"
"SATNUM \n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"/\n"
"MULTNUM \n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"1 1 2 2 2\n"
"/\n"
"MULTIREG\n"
" SATNUM 11 1 M / \n"
" SATNUM 20 2 / \n"
"/\n"
"EDIT\n"
"\n";
Opm::ParserPtr parser(new Opm::Parser());
return parser->parseString(deckData) ;
}
BOOST_AUTO_TEST_CASE(InvalidArrayThrows) {
Opm::DeckPtr deck = createDeckInvalidArray();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(InvalidRegionThrows) {
Opm::DeckPtr deck = createDeckInvalidRegion();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(ExpectedIntThrows) {
Opm::DeckPtr deck = createDeckInvalidValue();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(MissingRegionVectorThrows) {
Opm::DeckPtr deck = createDeckMissingVector();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(UnInitializedVectorThrows) {
Opm::DeckPtr deck = createDeckUnInitialized();
BOOST_CHECK_THROW( new Opm::EclipseState(deck) , std::invalid_argument );
}
BOOST_AUTO_TEST_CASE(IntSetCorrectly) {
Opm::DeckPtr deck = createValidIntDeck();
Opm::EclipseState state(deck);
std::shared_ptr<Opm::GridProperty<int> > property = state.getIntGridProperty( "SATNUM");
for (size_t j=0; j< 5; j++)
for (size_t i = 0; i < 5; i++) {
if (i < 2)
BOOST_CHECK_EQUAL( 11 , property->iget(i,j,0));
else
BOOST_CHECK_EQUAL( 40 , property->iget(i,j,0));
}
}

19
opm/parser/eclipse/EclipseState/Schedule/Completion.cpp
View File

@@ -23,11 +23,11 @@
namespace Opm {
Completion::Completion(int i, int j , int k , CompletionStateEnum state ,
Completion::Completion(int i, int j , int k , WellCompletion::StateEnum state ,
const Value<double>& connectionTransmissibilityFactor,
const Value<double>& diameter,
const Value<double>& skinFactor,
const CompletionDirection::DirectionEnum direction)
const WellCompletion::DirectionEnum direction)
: m_i(i), m_j(j), m_k(k),
m_diameter(diameter),
m_connectionTransmissibilityFactor(connectionTransmissibilityFactor),
@@ -61,7 +61,7 @@ namespace Opm {
int J = compdatRecord->getItem("J")->getInt(0) - 1;
int K1 = compdatRecord->getItem("K1")->getInt(0) - 1;
int K2 = compdatRecord->getItem("K2")->getInt(0) - 1;
CompletionStateEnum state = CompletionStateEnumFromString( compdatRecord->getItem("STATE")->getTrimmedString(0) );
WellCompletion::StateEnum state = WellCompletion::StateEnumFromString( compdatRecord->getItem("STATE")->getTrimmedString(0) );
Value<double> connectionTransmissibilityFactor("ConnectionTransmissibilityFactor");
Value<double> diameter("Diameter");
Value<double> skinFactor("SkinFactor");
@@ -74,11 +74,14 @@ namespace Opm {
if (!connectionTransmissibilityFactorItem->defaultApplied(0))
connectionTransmissibilityFactor.setValue(connectionTransmissibilityFactorItem->getSIDouble(0));
diameter.setValue( diameterItem->getSIDouble(0));
skinFactor.setValue( skinFactorItem->getRawDouble(0));
if (diameterItem->hasValue(0))
diameter.setValue( diameterItem->getSIDouble(0));
if (skinFactorItem->hasValue(0))
skinFactor.setValue( skinFactorItem->getRawDouble(0));
}
const CompletionDirection::DirectionEnum& direction = CompletionDirection::DirectionEnumFromString(compdatRecord->getItem("DIR")->getTrimmedString(0));
const WellCompletion::DirectionEnum direction = WellCompletion::DirectionEnumFromString(compdatRecord->getItem("DIR")->getTrimmedString(0));
for (int k = K1; k <= K2; k++) {
CompletionPtr completion(new Completion(I , J , k , state , connectionTransmissibilityFactor, diameter, skinFactor, direction ));
@@ -140,7 +143,7 @@ namespace Opm {
return m_k;
}
CompletionStateEnum Completion::getState() const {
WellCompletion::StateEnum Completion::getState() const {
return m_state;
}
@@ -156,7 +159,7 @@ namespace Opm {
return m_skinFactor.getValue();
}
CompletionDirection::DirectionEnum Completion::getDirection() const {
WellCompletion::DirectionEnum Completion::getDirection() const {
return m_direction;
}
}

12
opm/parser/eclipse/EclipseState/Schedule/Completion.hpp
View File

@@ -35,23 +35,23 @@ namespace Opm {
class Completion {
public:
Completion(int i, int j , int k , CompletionStateEnum state ,
Completion(int i, int j , int k , WellCompletion::StateEnum state ,
const Value<double>& connectionTransmissibilityFactor,
const Value<double>& diameter,
const Value<double>& skinFactor,
const CompletionDirection::DirectionEnum direction = CompletionDirection::DirectionEnum::Z);
const WellCompletion::DirectionEnum direction = WellCompletion::DirectionEnum::Z);
bool sameCoordinate(const Completion& other) const;
int getI() const;
int getJ() const;
int getK() const;
CompletionStateEnum getState() const;
WellCompletion::StateEnum getState() const;
double getConnectionTransmissibilityFactor() const;
double getDiameter() const;
double getSkinFactor() const;
void fixDefaultIJ(int wellHeadI , int wellHeadJ);
CompletionDirection::DirectionEnum getDirection() const;
WellCompletion::DirectionEnum getDirection() const;
static std::map<std::string , std::vector<std::shared_ptr<Completion> > > completionsFromCOMPDATKeyword( DeckKeywordConstPtr compdatKeyword );
static std::pair<std::string , std::vector<std::shared_ptr<Completion> > > completionsFromCOMPDATRecord( DeckRecordConstPtr compdatRecord );
@@ -61,8 +61,8 @@ namespace Opm {
Value<double> m_diameter;
Value<double> m_connectionTransmissibilityFactor;
Value<double> m_skinFactor;
CompletionStateEnum m_state;
CompletionDirection::DirectionEnum m_direction;
WellCompletion::StateEnum m_state;
WellCompletion::DirectionEnum m_direction;
};
typedef std::shared_ptr<Completion> CompletionPtr;

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

@@ -17,36 +17,39 @@
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");
@@ -56,66 +59,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);
}
@@ -128,7 +131,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();
@@ -146,7 +149,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);
@@ -157,12 +160,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);
@@ -170,7 +173,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);
@@ -178,7 +181,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);
@@ -187,7 +190,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);
@@ -195,7 +198,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);
@@ -236,7 +239,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);
@@ -249,15 +252,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);
@@ -326,7 +329,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);
@@ -355,7 +358,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);
@@ -386,7 +389,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);
//record->getItem(1)->hasValue(0);
@@ -493,7 +496,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);
@@ -526,7 +529,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);
@@ -548,7 +551,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;
@@ -559,7 +562,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);
@@ -580,7 +583,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;

134
opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.cpp
View File

@@ -26,31 +26,78 @@
namespace Opm {
const std::string CompletionStateEnum2String( CompletionStateEnum enumValue ) {
switch( enumValue ) {
case OPEN:
return "OPEN";
case AUTO:
return "AUTO";
case SHUT:
return "SHUT";
default:
throw std::invalid_argument("Unhandled enum value");
namespace WellCompletion {
std::string
DirectionEnum2String(const DirectionEnum enumValue)
{
std::string stringValue;
switch (enumValue) {
case DirectionEnum::X:
stringValue = "X";
break;
case DirectionEnum::Y:
stringValue = "Y";
break;
case DirectionEnum::Z:
stringValue = "Z";
break;
}
return stringValue;
}
DirectionEnum
DirectionEnumFromString(const std::string& stringValue)
{
std::string s(stringValue);
boost::algorithm::trim(s);
DirectionEnum direction;
if (s == "X") { direction = DirectionEnum::X; }
else if (s == "Y") { direction = DirectionEnum::Y; }
else if (s == "Z") { direction = DirectionEnum::Z; }
else {
std::string msg = "Unsupported completion direction " + s;
throw std::invalid_argument(msg);
}
return direction;
}
}
CompletionStateEnum CompletionStateEnumFromString( const std::string& origStringValue ) {
std::string stringValue(origStringValue);
boost::algorithm::trim(stringValue);
if (stringValue == "OPEN")
return OPEN;
else if (stringValue == "SHUT")
return SHUT;
else if (stringValue == "AUTO")
return AUTO;
else
throw std::invalid_argument("Unknown enum state string: " + stringValue );
const std::string StateEnum2String( StateEnum enumValue ) {
switch( enumValue ) {
case OPEN:
return "OPEN";
case AUTO:
return "AUTO";
case SHUT:
return "SHUT";
default:
throw std::invalid_argument("Unhandled enum value");
}
}
StateEnum StateEnumFromString( const std::string& origStringValue ) {
std::string stringValue(origStringValue);
boost::algorithm::trim(stringValue);
if (stringValue == "OPEN")
return OPEN;
else if (stringValue == "SHUT")
return SHUT;
else if (stringValue == "STOP")
return SHUT;
else if (stringValue == "AUTO")
return AUTO;
else
throw std::invalid_argument("Unknown enum state string: " + stringValue );
}
}
/*****************************************************************/
@@ -449,47 +496,4 @@ namespace Opm {
}
}
namespace CompletionDirection {
std::string
DirectionEnum2String(const DirectionEnum enumValue)
{
std::string stringValue;
switch (enumValue) {
case DirectionEnum::X:
stringValue = "X";
break;
case DirectionEnum::Y:
stringValue = "Y";
break;
case DirectionEnum::Z:
stringValue = "Z";
break;
}
return stringValue;
}
DirectionEnum
DirectionEnumFromString(const std::string& stringValue)
{
std::string s(stringValue);
boost::algorithm::trim(s);
DirectionEnum direction;
if (s == "X") { direction = DirectionEnum::X; }
else if (s == "Y") { direction = DirectionEnum::Y; }
else if (s == "Z") { direction = DirectionEnum::Z; }
else {
std::string msg = "Unsupported completion direction " + s;
throw std::invalid_argument(msg);
}
return direction;
}
} // namespace CompletionDirection
}

20
opm/parser/eclipse/EclipseState/Schedule/ScheduleEnums.hpp
View File

@@ -37,15 +37,15 @@ namespace Opm {
StatusEnum StatusFromString(const std::string& stringValue);
}
namespace WellCompletion {
enum CompletionStateEnum {
OPEN = 1,
SHUT = 2,
AUTO = 3
};
enum StateEnum {
OPEN = 1,
SHUT = 2,
AUTO = 3
};
namespace CompletionDirection {
enum DirectionEnum {
X = 1,
Y = 2,
@@ -54,7 +54,10 @@ namespace Opm {
std::string DirectionEnum2String(const DirectionEnum enumValue);
DirectionEnum DirectionEnumFromString(const std::string& stringValue);
} // namespace CompletionDirection
const std::string StateEnum2String( StateEnum enumValue );
StateEnum StateEnumFromString( const std::string& stringValue );
}
namespace Phase {
@@ -201,9 +204,6 @@ namespace Opm {
GuideRatePhaseEnum GuideRatePhaseEnumFromString( const std::string& stringValue );
}
const std::string CompletionStateEnum2String( CompletionStateEnum enumValue );
CompletionStateEnum CompletionStateEnumFromString( const std::string& stringValue );
}

6
opm/parser/eclipse/EclipseState/Schedule/WellInjectionProperties.hpp
View File

@@ -44,15 +44,13 @@ namespace Opm {
}
void dropInjectionControl(WellInjector::ControlModeEnum controlModeArg) {
if ((injectionControls & controlModeArg) != 0) {
if ((injectionControls & controlModeArg) != 0)
injectionControls -= controlModeArg;
}
}
void addInjectionControl(WellInjector::ControlModeEnum controlModeArg) {
if ((injectionControls & controlModeArg) == 0) {
if ((injectionControls & controlModeArg) == 0)
injectionControls += controlModeArg;
}
}
};
}

22
opm/parser/eclipse/EclipseState/Schedule/WellProductionProperties.cpp
View File

@@ -113,20 +113,16 @@ namespace Opm {
return p;
}
void
WellProductionProperties::init()
{
// public: properties (in order of declaration)
OilRate = 0.0;
GasRate = 0.0;
WaterRate = 0.0;
LiquidRate = 0.0;
ResVRate = 0.0;
BHPLimit = 0.0;
THPLimit = 0.0;
void WellProductionProperties::init() {
OilRate = 0.0;
GasRate = 0.0;
WaterRate = 0.0;
LiquidRate = 0.0;
ResVRate = 0.0;
BHPLimit = 0.0;
THPLimit = 0.0;
controlMode = WellProducer::CMODE_UNDEFINED;
// private: property
productionControls = 0;
m_productionControls = 0;
}
} // namespace Opm

35
opm/parser/eclipse/EclipseState/Schedule/WellProductionProperties.hpp
View File

@@ -38,41 +38,30 @@ namespace Opm {
WellProductionProperties();
static WellProductionProperties
history(DeckRecordConstPtr record);
static WellProductionProperties history(DeckRecordConstPtr record);
static WellProductionProperties
prediction(DeckRecordConstPtr record);
static WellProductionProperties prediction(DeckRecordConstPtr record);
bool
hasProductionControl(WellProducer::ControlModeEnum controlModeArg) const
{
return (productionControls & controlModeArg) != 0;
bool hasProductionControl(WellProducer::ControlModeEnum controlModeArg) const {
return (m_productionControls & controlModeArg) != 0;
}
void
dropProductionControl(WellProducer::ControlModeEnum controlModeArg)
{
if (hasProductionControl(controlModeArg)) {
productionControls -= controlModeArg;
}
void dropProductionControl(WellProducer::ControlModeEnum controlModeArg) {
if (hasProductionControl(controlModeArg))
m_productionControls -= controlModeArg;
}
void
addProductionControl(WellProducer::ControlModeEnum controlModeArg)
{
if (! hasProductionControl(controlModeArg)) {
productionControls += controlModeArg;
}
void addProductionControl(WellProducer::ControlModeEnum controlModeArg) {
if (! hasProductionControl(controlModeArg))
m_productionControls += controlModeArg;
}
private:
int productionControls;
int m_productionControls;
WellProductionProperties(DeckRecordConstPtr record);
void
init();
void init();
};
} // namespace Opm

4
opm/parser/eclipse/EclipseState/Schedule/WellSet.cpp
View File

@@ -38,7 +38,7 @@ namespace Opm {
if (hasWell(wellName))
return m_wells.find(wellName)->second;
else
throw std::invalid_argument("Does not have this well?!\n");
throw std::invalid_argument("Do not have well '"+wellName+"'?!\n");
}
@@ -55,7 +55,7 @@ namespace Opm {
if (hasWell(wellName))
m_wells.erase( wellName );
else
throw std::invalid_argument("Does not have this well?");
throw std::invalid_argument("Cannot delete unknown well '"+wellName+"'");
}

18
opm/parser/eclipse/EclipseState/Schedule/tests/CompletionSetTests.cpp
View File

@@ -48,8 +48,8 @@ BOOST_AUTO_TEST_CASE(CreateCompletionSetOK) {
BOOST_AUTO_TEST_CASE(AddCompletionSizeCorrect) {
Opm::CompletionSet completionSet;
Opm::CompletionConstPtr completion1(new Opm::Completion(10,10,10,Opm::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion2(new Opm::Completion(11,10,10,Opm::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion1(new Opm::Completion(10,10,10,Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion2(new Opm::Completion(11,10,10,Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
completionSet.add( completion1 );
BOOST_CHECK_EQUAL( 1U , completionSet.size() );
@@ -62,8 +62,8 @@ BOOST_AUTO_TEST_CASE(AddCompletionSizeCorrect) {
BOOST_AUTO_TEST_CASE(CompletionSetGetOutOfRangeThrows) {
Opm::CompletionSet completionSet;
Opm::CompletionConstPtr completion1(new Opm::Completion(10,10,10,Opm::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion2(new Opm::Completion(11,10,10,Opm::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion1(new Opm::Completion(10,10,10,Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion2(new Opm::Completion(11,10,10,Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
completionSet.add( completion1 );
BOOST_CHECK_EQUAL( 1U , completionSet.size() );
@@ -78,8 +78,8 @@ BOOST_AUTO_TEST_CASE(CompletionSetGetOutOfRangeThrows) {
BOOST_AUTO_TEST_CASE(AddCompletionSameCellUpdates) {
Opm::CompletionSet completionSet;
Opm::CompletionConstPtr completion1(new Opm::Completion(10,10,10,Opm::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion2(new Opm::Completion(10,10,10,Opm::SHUT , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion1(new Opm::Completion(10,10,10,Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion2(new Opm::Completion(10,10,10,Opm::WellCompletion::SHUT , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
completionSet.add( completion1 );
@@ -94,9 +94,9 @@ BOOST_AUTO_TEST_CASE(AddCompletionSameCellUpdates) {
BOOST_AUTO_TEST_CASE(AddCompletionShallowCopy) {
Opm::CompletionSet completionSet;
Opm::CompletionConstPtr completion1(new Opm::Completion(10,10,10,Opm::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion2(new Opm::Completion(10,10,11,Opm::SHUT , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion3(new Opm::Completion(10,10,12,Opm::SHUT , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion1(new Opm::Completion(10,10,10,Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion2(new Opm::Completion(10,10,11,Opm::WellCompletion::SHUT , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionConstPtr completion3(new Opm::Completion(10,10,12,Opm::WellCompletion::SHUT , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
completionSet.add( completion1 );
completionSet.add( completion2 );

16
opm/parser/eclipse/EclipseState/Schedule/tests/CompletionTests.cpp
View File

@@ -39,17 +39,17 @@
BOOST_AUTO_TEST_CASE(CreateCompletionOK) {
Opm::Completion completion(10,10,10,Opm::OPEN,Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
Opm::Completion completion(10,10,10,Opm::WellCompletion::OPEN,Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
}
BOOST_AUTO_TEST_CASE(testGetFunctions) {
Opm::Completion completion(10,11,12,Opm::OPEN,Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
Opm::Completion completion(10,11,12,Opm::WellCompletion::OPEN,Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
BOOST_CHECK_EQUAL( 10 , completion.getI() );
BOOST_CHECK_EQUAL( 11 , completion.getJ() );
BOOST_CHECK_EQUAL( 12 , completion.getK() );
BOOST_CHECK_EQUAL( Opm::OPEN , completion.getState());
BOOST_CHECK_EQUAL( Opm::WellCompletion::OPEN , completion.getState());
BOOST_CHECK_EQUAL( 99.88 , completion.getConnectionTransmissibilityFactor());
BOOST_CHECK_EQUAL( 22.33 , completion.getDiameter());
BOOST_CHECK_EQUAL( 33.22 , completion.getSkinFactor());
@@ -57,11 +57,11 @@ BOOST_AUTO_TEST_CASE(testGetFunctions) {
BOOST_AUTO_TEST_CASE(CompletionTestssameCoordinate) {
Opm::Completion completion1(10,10,10,Opm::OPEN, Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
Opm::Completion completion2(10,10,10,Opm::OPEN, Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
Opm::Completion completion3(11,10,10,Opm::OPEN, Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
Opm::Completion completion4(10,11,10,Opm::OPEN, Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
Opm::Completion completion5(10,10,11,Opm::OPEN, Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
Opm::Completion completion1(10,10,10,Opm::WellCompletion::OPEN, Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
Opm::Completion completion2(10,10,10,Opm::WellCompletion::OPEN, Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
Opm::Completion completion3(11,10,10,Opm::WellCompletion::OPEN, Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
Opm::Completion completion4(10,11,10,Opm::WellCompletion::OPEN, Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
Opm::Completion completion5(10,10,11,Opm::WellCompletion::OPEN, Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22));
BOOST_CHECK( completion1.sameCoordinate( completion2 ));
BOOST_CHECK_EQUAL( false , completion1.sameCoordinate( completion3 ));

33
opm/parser/eclipse/EclipseState/Schedule/tests/ScheduleEnumTests.cpp
View File

@@ -26,29 +26,30 @@
using namespace Opm;
BOOST_AUTO_TEST_CASE(TestCompletionStateEnum2String) {
BOOST_CHECK_EQUAL( "AUTO" , CompletionStateEnum2String(AUTO));
BOOST_CHECK_EQUAL( "OPEN" , CompletionStateEnum2String(OPEN));
BOOST_CHECK_EQUAL( "SHUT" , CompletionStateEnum2String(SHUT));
BOOST_CHECK_EQUAL( "AUTO" , WellCompletion::StateEnum2String(WellCompletion::AUTO));
BOOST_CHECK_EQUAL( "OPEN" , WellCompletion::StateEnum2String(WellCompletion::OPEN));
BOOST_CHECK_EQUAL( "SHUT" , WellCompletion::StateEnum2String(WellCompletion::SHUT));
}
BOOST_AUTO_TEST_CASE(TestCompletionStateEnumFromString) {
BOOST_CHECK_THROW( CompletionStateEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( AUTO , CompletionStateEnumFromString("AUTO"));
BOOST_CHECK_EQUAL( SHUT , CompletionStateEnumFromString("SHUT"));
BOOST_CHECK_EQUAL( OPEN , CompletionStateEnumFromString("OPEN"));
BOOST_CHECK_THROW( WellCompletion::StateEnumFromString("XXX") , std::invalid_argument );
BOOST_CHECK_EQUAL( WellCompletion::AUTO , WellCompletion::StateEnumFromString("AUTO"));
BOOST_CHECK_EQUAL( WellCompletion::SHUT , WellCompletion::StateEnumFromString("SHUT"));
BOOST_CHECK_EQUAL( WellCompletion::SHUT , WellCompletion::StateEnumFromString("STOP"));
BOOST_CHECK_EQUAL( WellCompletion::OPEN , WellCompletion::StateEnumFromString("OPEN"));
}
BOOST_AUTO_TEST_CASE(TestCompletionStateEnumLoop) {
BOOST_CHECK_EQUAL( AUTO , CompletionStateEnumFromString( CompletionStateEnum2String( AUTO ) ));
BOOST_CHECK_EQUAL( SHUT , CompletionStateEnumFromString( CompletionStateEnum2String( SHUT ) ));
BOOST_CHECK_EQUAL( OPEN , CompletionStateEnumFromString( CompletionStateEnum2String( OPEN ) ));
BOOST_CHECK_EQUAL( WellCompletion::AUTO , WellCompletion::StateEnumFromString( WellCompletion::StateEnum2String( WellCompletion::AUTO ) ));
BOOST_CHECK_EQUAL( WellCompletion::SHUT , WellCompletion::StateEnumFromString( WellCompletion::StateEnum2String( WellCompletion::SHUT ) ));
BOOST_CHECK_EQUAL( WellCompletion::OPEN , WellCompletion::StateEnumFromString( WellCompletion::StateEnum2String( WellCompletion::OPEN ) ));
BOOST_CHECK_EQUAL( "AUTO" , CompletionStateEnum2String(CompletionStateEnumFromString( "AUTO" ) ));
BOOST_CHECK_EQUAL( "OPEN" , CompletionStateEnum2String(CompletionStateEnumFromString( "OPEN" ) ));
BOOST_CHECK_EQUAL( "SHUT" , CompletionStateEnum2String(CompletionStateEnumFromString( "SHUT" ) ));
BOOST_CHECK_EQUAL( "AUTO" , WellCompletion::StateEnum2String(WellCompletion::StateEnumFromString( "AUTO" ) ));
BOOST_CHECK_EQUAL( "OPEN" , WellCompletion::StateEnum2String(WellCompletion::StateEnumFromString( "OPEN" ) ));
BOOST_CHECK_EQUAL( "SHUT" , WellCompletion::StateEnum2String(WellCompletion::StateEnumFromString( "SHUT" ) ));
}
@@ -56,7 +57,7 @@ BOOST_AUTO_TEST_CASE(TestCompletionStateEnumLoop) {
BOOST_AUTO_TEST_CASE(TestCompletionDirectionEnum2String)
{
using namespace CompletionDirection;
using namespace WellCompletion;
BOOST_CHECK_EQUAL("X", DirectionEnum2String(DirectionEnum::X));
BOOST_CHECK_EQUAL("Y", DirectionEnum2String(DirectionEnum::Y));
@@ -65,7 +66,7 @@ BOOST_AUTO_TEST_CASE(TestCompletionDirectionEnum2String)
BOOST_AUTO_TEST_CASE(TestCompletionDirectionEnumFromString)
{
using namespace CompletionDirection;
using namespace WellCompletion;
BOOST_CHECK_THROW(DirectionEnumFromString("XXX"), std::invalid_argument);
@@ -76,7 +77,7 @@ BOOST_AUTO_TEST_CASE(TestCompletionDirectionEnumFromString)
BOOST_AUTO_TEST_CASE(TestCompletionDirectionEnumLoop)
{
using namespace CompletionDirection;
using namespace WellCompletion;
BOOST_CHECK_EQUAL(DirectionEnum::X, DirectionEnumFromString(DirectionEnum2String(DirectionEnum::X)));
BOOST_CHECK_EQUAL(DirectionEnum::Y, DirectionEnumFromString(DirectionEnum2String(DirectionEnum::Y)));

93
opm/parser/eclipse/EclipseState/Schedule/tests/WellPropertiesTests.cpp
View File

@@ -31,9 +31,7 @@
namespace {
namespace WCONHIST {
std::string
all_specified_CMODE_BHP()
{
std::string all_specified_CMODE_BHP() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'BHP' 1 2 3/\n/\n";
@@ -43,9 +41,7 @@ namespace {
std::string
all_specified()
{
std::string all_specified() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'ORAT' 1 2 3/\n/\n";
@@ -53,9 +49,7 @@ namespace {
return input;
}
std::string
orat_defaulted()
{
std::string orat_defaulted() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'WRAT' 1* 2 3/\n/\n";
@@ -63,9 +57,7 @@ namespace {
return input;
}
std::string
owrat_defaulted()
{
std::string owrat_defaulted() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'GRAT' 1* 1* 3/\n/\n";
@@ -73,9 +65,7 @@ namespace {
return input;
}
std::string
all_defaulted()
{
std::string all_defaulted() {
const std::string input =
"WCONHIST\n"
"'P' 'OPEN' 'LRAT'/\n/\n";
@@ -83,9 +73,7 @@ namespace {
return input;
}
std::string
all_defaulted_with_bhp()
{
std::string all_defaulted_with_bhp() {
const std::string input =
"WCONHIST\n"
"-- 1 2 3 4-9 10\n"
@@ -94,14 +82,11 @@ namespace {
return input;
}
Opm::WellProductionProperties
properties(const std::string& input)
{
Opm::WellProductionProperties properties(const std::string& input) {
Opm::Parser parser;
Opm::DeckPtr deck = parser.parseString(input);
Opm::DeckKeywordConstPtr kwd = deck->getKeyword("WCONHIST");
Opm::DeckRecordConstPtr record = kwd->getRecord(0);
Opm::DeckPtr deck = parser.parseString(input);
Opm::DeckRecordConstPtr record = deck->getKeyword("WCONHIST")->getRecord(0);
return Opm::WellProductionProperties::history(record);
}
@@ -141,16 +126,16 @@ BOOST_AUTO_TEST_CASE(WCH_All_Specified_BHP_Defaulted)
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::ORAT);
// BHP must be explicitly provided/specified
BOOST_REQUIRE(! p.hasProductionControl(Opm::WellProducer::BHP));
BOOST_CHECK(! p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(WCH_ORAT_Defaulted_BHP_Defaulted)
@@ -160,15 +145,15 @@ BOOST_AUTO_TEST_CASE(WCH_ORAT_Defaulted_BHP_Defaulted)
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::WRAT);
// BHP must be explicitly provided/specified
BOOST_REQUIRE(! p.hasProductionControl(Opm::WellProducer::BHP));
BOOST_CHECK(! p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(WCH_OWRAT_Defaulted_BHP_Defaulted)
@@ -178,15 +163,15 @@ BOOST_AUTO_TEST_CASE(WCH_OWRAT_Defaulted_BHP_Defaulted)
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::GRAT);
// BHP must be explicitly provided/specified
BOOST_REQUIRE(! p.hasProductionControl(Opm::WellProducer::BHP));
BOOST_CHECK(! p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(WCH_Rates_Defaulted_BHP_Defaulted)
@@ -196,15 +181,15 @@ BOOST_AUTO_TEST_CASE(WCH_Rates_Defaulted_BHP_Defaulted)
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::LRAT);
// BHP must be explicitly provided/specified
BOOST_REQUIRE(! p.hasProductionControl(Opm::WellProducer::BHP));
BOOST_CHECK(! p.hasProductionControl(Opm::WellProducer::BHP));
}
BOOST_AUTO_TEST_CASE(WCH_Rates_Defaulted_BHP_Specified)
@@ -214,15 +199,15 @@ BOOST_AUTO_TEST_CASE(WCH_Rates_Defaulted_BHP_Specified)
// WCONHIST always supports {O,W,G}RAT, LRAT, and
// RESV--irrespective of actual specification.
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::ORAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::WRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::GRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::LRAT));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::RESV));
BOOST_CHECK_EQUAL(p.controlMode , Opm::WellProducer::RESV);
// BHP must be explicitly provided/specified
BOOST_REQUIRE(p.hasProductionControl(Opm::WellProducer::BHP));
BOOST_CHECK(p.hasProductionControl(Opm::WellProducer::BHP));
}

10
opm/parser/eclipse/EclipseState/Schedule/tests/WellTests.cpp
View File

@@ -171,11 +171,11 @@ BOOST_AUTO_TEST_CASE(UpdateCompletions) {
std::vector<Opm::CompletionPtr> newCompletions;
std::vector<Opm::CompletionPtr> newCompletions2;
Opm::CompletionPtr comp1(new Opm::Completion( 10 , 10 , 10 , Opm::AUTO , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionPtr comp2(new Opm::Completion( 10 , 11 , 10 , Opm::SHUT , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionPtr comp3(new Opm::Completion( 10 , 10 , 12 , Opm::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionPtr comp4(new Opm::Completion( 10 , 10 , 12 , Opm::SHUT , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionPtr comp5(new Opm::Completion( 10 , 10 , 13 , Opm::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionPtr comp1(new Opm::Completion( 10 , 10 , 10 , Opm::WellCompletion::AUTO , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionPtr comp2(new Opm::Completion( 10 , 11 , 10 , Opm::WellCompletion::SHUT , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionPtr comp3(new Opm::Completion( 10 , 10 , 12 , Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionPtr comp4(new Opm::Completion( 10 , 10 , 12 , Opm::WellCompletion::SHUT , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
Opm::CompletionPtr comp5(new Opm::Completion( 10 , 10 , 13 , Opm::WellCompletion::OPEN , Opm::Value<double>("ConnectionTransmissibilityFactor",99.88), Opm::Value<double>("D",22.33), Opm::Value<double>("SKIN",33.22)));
//std::vector<Opm::CompletionConstPtr> newCompletions2{ comp4 , comp5}; Newer c++

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

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

@@ -38,16 +38,6 @@
using namespace Opm;
/*
There is something fishy with the tests involving grid property post
processors. It seems that halfways through the test suddenly the
adress of a EclipseState object from a previous test is used; this
leads to segmentation fault. The problem is 'solved' by having
running this test first.
An issue has been posted on Stackoverflow: questions/26275555
*/
static DeckPtr createDeckTOP() {
const char *deckData =
@@ -97,8 +87,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 +214,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);
}

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

@@ -29,31 +29,21 @@
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() , false);
EclipseState state(deck, parserLog);
DeckPtr deck = parser->parseFile(boxFile.string());
EclipseState state(deck, logger);
return state;
}
/*
There is something fishy with the tests involving grid property post
processors. It seems that halfways through the test suddenly the
adress of a EclipseState object from a previous test is used; this
leads to segmentation fault. The problem is 'solved' by having
running this test first.
An issue has been posted on Stackoverflow: questions/26275555
*/
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 +65,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 +90,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 +114,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");

47
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,43 +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));
}
{
// deck contains an unknown keyword "FOO"
const char *incorrectDeckString =
"RUNSPEC\n"
"FOO\n"
"DIMENS\n"
"3 3 3 /\n"
"GRID\n"
"DXV\n"
"1 1 1 /\n"
"DYV\n"
"1 1 1 /\n"
"DZV\n"
"1 1 1 /\n"
"TOPS\n"
"9*100 /\n"
"PROPS\n"
"SOLUTION\n"
"SCHEDULE\n";
auto deck = parser->parseString(incorrectDeckString, /*strict=*/false);
Opm::ParserLogPtr parserLog(new Opm::ParserLog());
BOOST_CHECK(!Opm::checkDeck(deck, parserLog));
// this is supposed to succeed as we ensure everything except that all keywords
// are known
BOOST_CHECK(Opm::checkDeck(deck, parserLog, ~Opm::UnknownKeywords));
BOOST_CHECK(!Opm::checkDeck(deck, logger, Opm::SectionTopology | Opm::KeywordSection));
}
}

16
opm/parser/eclipse/IntegrationTests/CompletionsFromDeck.cpp
View File

@@ -57,16 +57,16 @@ BOOST_AUTO_TEST_CASE( CreateCompletionsFromRecord ) {
BOOST_CHECK_EQUAL( 29 , completion0->getI() );
BOOST_CHECK_EQUAL( 36 , completion0->getJ() );
BOOST_CHECK_EQUAL( 0 , completion0->getK() );
BOOST_CHECK_EQUAL( OPEN , completion0->getState() );
BOOST_CHECK_EQUAL( WellCompletion::OPEN , completion0->getState() );
BOOST_CHECK_EQUAL( 3.8134259259259256e-12 , completion0->getConnectionTransmissibilityFactor() );
BOOST_CHECK_EQUAL( Opm::CompletionDirection::DirectionEnum::X, completion0->getDirection() );
BOOST_CHECK_EQUAL( WellCompletion::DirectionEnum::X, completion0->getDirection() );
BOOST_CHECK_EQUAL( 29 , completion2->getI() );
BOOST_CHECK_EQUAL( 36 , completion2->getJ() );
BOOST_CHECK_EQUAL( 2 , completion2->getK() );
BOOST_CHECK_EQUAL( OPEN , completion2->getState() );
BOOST_CHECK_EQUAL( WellCompletion::OPEN , completion2->getState() );
BOOST_CHECK_EQUAL( 3.8134259259259256e-12 , completion2->getConnectionTransmissibilityFactor() );
BOOST_CHECK_EQUAL( Opm::CompletionDirection::DirectionEnum::X, completion2->getDirection() );
BOOST_CHECK_EQUAL( WellCompletion::DirectionEnum::X, completion2->getDirection() );
}
{
@@ -110,16 +110,16 @@ BOOST_AUTO_TEST_CASE( CreateCompletionsFromKeyword ) {
BOOST_CHECK_EQUAL( 30 , completion0->getI() );
BOOST_CHECK_EQUAL( 17 , completion0->getJ() );
BOOST_CHECK_EQUAL( 0 , completion0->getK() );
BOOST_CHECK_EQUAL( OPEN , completion0->getState() );
BOOST_CHECK_EQUAL( WellCompletion::OPEN , completion0->getState() );
BOOST_CHECK_EQUAL( 3.1726851851851847e-12 , completion0->getConnectionTransmissibilityFactor() );
BOOST_CHECK_EQUAL( Opm::CompletionDirection::DirectionEnum::Y, completion0->getDirection() );
BOOST_CHECK_EQUAL( WellCompletion::DirectionEnum::Y, completion0->getDirection() );
BOOST_CHECK_EQUAL( 30 , completion4->getI() );
BOOST_CHECK_EQUAL( 16 , completion4->getJ() );
BOOST_CHECK_EQUAL( 3 , completion4->getK() );
BOOST_CHECK_EQUAL( OPEN , completion4->getState() );
BOOST_CHECK_EQUAL( WellCompletion::OPEN , completion4->getState() );
BOOST_CHECK_EQUAL( 5.4722222222222212e-13 , completion4->getConnectionTransmissibilityFactor() );
BOOST_CHECK_EQUAL( Opm::CompletionDirection::DirectionEnum::Y, completion4->getDirection() );
BOOST_CHECK_EQUAL( WellCompletion::DirectionEnum::Y, completion4->getDirection() );
}

35
opm/parser/eclipse/IntegrationTests/IntegrationTests.cpp
View File

@@ -203,17 +203,9 @@ BOOST_AUTO_TEST_CASE(parse_fileWithBPRKeyword_dataiscorrect) {
/***************** Testing non-recognized keywords ********************/
BOOST_AUTO_TEST_CASE(parse_unknownkeywordWithnonstrictparsing_keywordmarked) {
BOOST_AUTO_TEST_CASE(parse_unknownkeyword_exceptionthrown) {
ParserPtr parser(new Parser());
DeckPtr deck = parser->parseFile("testdata/integration_tests/someobscureelements.data", false);
BOOST_CHECK_EQUAL(4U, deck->size());
DeckKeywordConstPtr unknown = deck->getKeyword("GRUDINT");
BOOST_CHECK(!unknown->isKnown());
}
BOOST_AUTO_TEST_CASE(parse_unknownkeywordWithstrictparsing_exceptionthrown) {
ParserPtr parser(new Parser());
BOOST_CHECK_THROW( parser->parseFile("testdata/integration_tests/someobscureelements.data", true), std::invalid_argument);
BOOST_CHECK_THROW( parser->parseFile("testdata/integration_tests/someobscureelements.data"), std::invalid_argument);
}
/*********************Testing truncated (default) records ***************************/
@@ -223,27 +215,28 @@ BOOST_AUTO_TEST_CASE(parse_unknownkeywordWithstrictparsing_exceptionthrown) {
BOOST_AUTO_TEST_CASE(parse_truncatedrecords_deckFilledWithDefaults) {
ParserPtr parser(new Parser());
DeckPtr deck = parser->parseFile("testdata/integration_tests/truncated_records.data");
BOOST_CHECK_EQUAL(4U, deck->size());
BOOST_CHECK_EQUAL(3U, deck->size());
DeckKeywordConstPtr radfin4_0_full= deck->getKeyword("RADFIN4", 0);
DeckKeywordConstPtr radfin4_1_partial= deck->getKeyword("RADFIN4", 1);
DeckKeywordConstPtr radfin4_2_nodata= deck->getKeyword("RADFIN4", 2);
// Specified in datafile
BOOST_CHECK_EQUAL("NAME", radfin4_0_full->getRecord(0)->getItem(0)->getString(0));
BOOST_CHECK_EQUAL("NAME", radfin4_1_partial->getRecord(0)->getItem(0)->getString(0));
// Default string
BOOST_CHECK_NO_THROW(radfin4_2_nodata->getRecord(0)->getItem(0)->getString(0));
BOOST_CHECK( radfin4_2_nodata->getRecord(0)->getItem(0)->defaultApplied(0));
// Specified in datafile
BOOST_CHECK_EQUAL(213, radfin4_0_full->getRecord(0)->getItem(1)->getInt(0));
BOOST_CHECK_EQUAL(213, radfin4_1_partial->getRecord(0)->getItem(1)->getInt(0));
// Default int
BOOST_CHECK_NO_THROW( radfin4_2_nodata->getRecord(0)->getItem(1)->getInt(0));
BOOST_CHECK( radfin4_2_nodata->getRecord(0)->getItem(1)->defaultApplied(0));
const auto record_0 = radfin4_0_full->getRecord(0);
const auto lastItem_0 = record_0->getItem(record_0->size() - 1);
BOOST_CHECK(!lastItem_0->defaultApplied(0));
BOOST_CHECK_EQUAL(lastItem_0->getInt(0), 18);
const auto record_1 = radfin4_1_partial->getRecord(0);
const auto lastItem_1 = record_1->getItem(record_1->size() - 1);
BOOST_CHECK_EQUAL(213, radfin4_1_partial->getRecord(0)->getItem(1)->getInt(0));
BOOST_CHECK(lastItem_1->defaultApplied(0));
BOOST_CHECK_EQUAL(lastItem_1->getInt(0), 1);
ParserKeywordConstPtr parserKeyword = parser->getParserKeywordFromDeckName("RADFIN4");
ParserRecordConstPtr parserRecord = parserKeyword->getRecord();
@@ -252,6 +245,4 @@ BOOST_AUTO_TEST_CASE(parse_truncatedrecords_deckFilledWithDefaults) {
BOOST_CHECK_EQUAL(18, radfin4_0_full->getRecord(0)->getItem(10)->getInt(0));
BOOST_CHECK_EQUAL(intItem->getDefault(), radfin4_1_partial->getRecord(0)->getItem(10)->getInt(0));
BOOST_CHECK_EQUAL(intItem->getDefault(), radfin4_2_nodata->getRecord(0)->getItem(10)->getInt(0));
}

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

@@ -50,10 +50,10 @@ BOOST_AUTO_TEST_CASE( parse_ACTION_OK ) {
BOOST_REQUIRE( parser->isRecognizedKeyword( "WCONHIST" ));
BOOST_REQUIRE( parser->isRecognizedKeyword( "THROW" ));
BOOST_REQUIRE_THROW( parser->parseFile( actionFile2.string() , false) , std::invalid_argument );
BOOST_REQUIRE_THROW( parser->parseFile(actionFile2.string()) , std::invalid_argument );
ParserLogPtr parserLog(new ParserLog);
DeckPtr deck = parser->parseFile(actionFile.string() , false, 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,14 +76,10 @@ BOOST_AUTO_TEST_CASE( parse_ACTION_OK ) {
BOOST_CHECK_EQUAL( false , deck->hasKeyword( "DIMENS" ));
BOOST_CHECK_EQUAL( 2U , 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() , parserLog->getFileName(1));
BOOST_CHECK_EQUAL( 6U , parserLog->getLineNumber(1));
BOOST_CHECK_EQUAL( actionFile.string() , logger->getFileName(0));
BOOST_CHECK_EQUAL( 2U , logger->getLineNumber(0));
}
}

4
opm/parser/eclipse/IntegrationTests/ParseEND.cpp
View File

@@ -39,7 +39,7 @@ BOOST_AUTO_TEST_CASE( parse_END_OK ) {
ParserPtr parser(new Parser());
boost::filesystem::path fileWithTitleKeyword("testdata/integration_tests/END/END1.txt");
DeckPtr deck = parser->parseFile (fileWithTitleKeyword.string(), true);
DeckPtr deck = parser->parseFile(fileWithTitleKeyword.string());
BOOST_CHECK_EQUAL(size_t(1), deck->size());
BOOST_CHECK_EQUAL (true, deck->hasKeyword("OIL"));
@@ -51,7 +51,7 @@ BOOST_AUTO_TEST_CASE( parse_ENDINC_OK ) {
ParserPtr parser(new Parser());
boost::filesystem::path fileWithTitleKeyword("testdata/integration_tests/END/ENDINC1.txt");
DeckPtr deck = parser->parseFile (fileWithTitleKeyword.string(), true);
DeckPtr deck = parser->parseFile(fileWithTitleKeyword.string());
BOOST_CHECK_EQUAL(size_t(1), deck->size());
BOOST_CHECK_EQUAL (true, deck->hasKeyword("OIL"));

2
opm/parser/eclipse/IntegrationTests/ParseTITLE.cpp
View File

@@ -40,7 +40,7 @@ BOOST_AUTO_TEST_CASE( parse_TITLE_OK ) {
ParserPtr parser(new Parser());
boost::filesystem::path fileWithTitleKeyword("testdata/integration_tests/TITLE/TITLE1.txt");
DeckPtr deck = parser->parseFile (fileWithTitleKeyword.string(), true);
DeckPtr deck = parser->parseFile(fileWithTitleKeyword.string());
BOOST_CHECK_EQUAL(size_t(2), deck->size());
BOOST_CHECK_EQUAL (true, deck->hasKeyword("TITLE"));

13
opm/parser/eclipse/IntegrationTests/ScheduleCreateFromDeck.cpp
View File

@@ -34,6 +34,7 @@
using namespace Opm;
#if 0
BOOST_AUTO_TEST_CASE(CreateSchedule) {
@@ -73,7 +74,7 @@ BOOST_AUTO_TEST_CASE(WCONPROD_Missing_DATA) {
boost::filesystem::path scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_CMODE_MISSING_DATA");
DeckPtr deck = parser->parseFile(scheduleFile.string());
BOOST_CHECK_THROW( new Schedule(deck) , std::invalid_argument );
BOOST_CHECK_THROW( new Schedule(deck) , std::out_of_range );
}
@@ -191,6 +192,15 @@ BOOST_AUTO_TEST_CASE(WellTesting) {
}
}
BOOST_AUTO_TEST_CASE(WellTestCOMPDAT_DEFAULTED_ITEMS) {
ParserPtr parser(new Parser());
boost::filesystem::path scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_COMPDAT1");
DeckPtr deck = parser->parseFile(scheduleFile.string());
ScheduleConstPtr sched(new Schedule(deck));
}
BOOST_AUTO_TEST_CASE(WellTestCOMPDAT) {
ParserPtr parser(new Parser());
boost::filesystem::path scheduleFile("testdata/integration_tests/SCHEDULE/SCHEDULE_WELLS2");
@@ -591,6 +601,7 @@ BOOST_AUTO_TEST_CASE(WELLS_SHUT) {
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::SHUT , well2->getStatus(2));
BOOST_CHECK_EQUAL( WellCommon::StatusEnum::SHUT , well3->getStatus(2));
}
#endif
BOOST_AUTO_TEST_CASE(WellTestWPOLYMER) {
ParserPtr parser(new Parser());

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

96
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;
@@ -39,11 +40,9 @@ namespace Opm {
size_t lineNR;
std::shared_ptr<std::istream> inputstream;
RawKeywordPtr rawKeyword;
bool strictParsing;
std::string nextKeyword;
ParserState(const boost::filesystem::path &inputDataFile, DeckPtr deckToFill, const boost::filesystem::path &commonRootPath, bool useStrictParsing) {
ParserState(const boost::filesystem::path &inputDataFile, DeckPtr deckToFill, const boost::filesystem::path &commonRootPath) {
lineNR = 0;
strictParsing = useStrictParsing;
dataFile = inputDataFile;
deck = deckToFill;
rootPath = commonRootPath;
@@ -61,18 +60,16 @@ namespace Opm {
}
}
ParserState(const std::string &inputData, DeckPtr deckToFill, bool useStrictParsing) {
ParserState(const std::string &inputData, DeckPtr deckToFill) {
lineNR = 0;
strictParsing = useStrictParsing;
dataFile = "";
deck = deckToFill;
initSuccessful = true;
inputstream.reset(new std::istringstream(inputData));
}
ParserState(std::shared_ptr<std::istream> inputStream, DeckPtr deckToFill, bool useStrictParsing) {
ParserState(std::shared_ptr<std::istream> inputStream, DeckPtr deckToFill) {
lineNR = 0;
strictParsing = useStrictParsing;
dataFile = "";
deck = deckToFill;
initSuccessful = true;
@@ -93,9 +90,9 @@ namespace Opm {
is retained in the current implementation.
*/
DeckPtr Parser::parseFile(const std::string &dataFileName, bool strictParsing, 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), strictParsing));
std::shared_ptr<ParserState> parserState(new ParserState(dataFileName, DeckPtr(new Deck()), getRootPathFromFile(dataFileName)));
// warn if the file we'd like to parse does not exist or is not readable
if (!parserState->initSuccessful)
@@ -104,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, bool strictParsing, ParserLogPtr parserLog) const {
DeckPtr Parser::parseString(const std::string &data, LoggerPtr logger) const {
std::shared_ptr<ParserState> parserState(new ParserState(data, DeckPtr(new Deck()), strictParsing));
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, bool strictParsing, ParserLogPtr parserLog) const {
std::shared_ptr<ParserState> parserState(new ParserState(inputStream, DeckPtr(new Deck()), strictParsing));
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;
}
@@ -257,7 +254,6 @@ namespace Opm {
}
bool Parser::parseState(std::shared_ptr<ParserState> parserState) const {
bool verbose = false;
bool stopParsing = false;
if (parserState->inputstream) {
@@ -284,18 +280,14 @@ namespace Opm {
std::string includeFileAsString = readValueToken<std::string>(firstRecord->getItem(0));
boost::filesystem::path includeFile = getIncludeFilePath(parserState, includeFileAsString);
if (verbose)
std::cout << parserState->rawKeyword->getKeywordName() << " " << includeFile << std::endl;
std::shared_ptr<ParserState> newParserState (new ParserState(includeFile.string(), parserState->deck, parserState->rootPath, parserState->strictParsing));
std::shared_ptr<ParserState> newParserState (new ParserState(includeFile.string(), parserState->deck, parserState->rootPath));
if (!newParserState->initSuccessful)
throw std::invalid_argument("Included file '" + includeFile.string() + "' does not exist or is not readable.");
stopParsing = parseState(newParserState);
if (stopParsing) break;
} else {
if (verbose)
std::cout << parserState->rawKeyword->getKeywordName() << std::endl;
if (isRecognizedKeyword(parserState->rawKeyword->getKeywordName())) {
ParserKeywordConstPtr parserKeyword = getParserKeywordFromDeckName(parserState->rawKeyword->getKeywordName());
@@ -305,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());
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");
}
@@ -376,13 +368,8 @@ namespace Opm {
}
return RawKeywordPtr(new RawKeyword(keywordString, parserState->dataFile.string() , parserState->lineNR , targetSize , parserKeyword->isTableCollection()));
}
} else {
if (parserState->strictParsing) {
throw std::invalid_argument("Keyword " + keywordString + " not recognized ");
} else {
return RawKeywordPtr(new RawKeyword(keywordString, parserState->dataFile.string(), parserState->lineNR , 0));
}
}
} else
throw std::invalid_argument("Keyword " + keywordString + " not recognized ");
}
@@ -400,11 +387,24 @@ namespace Opm {
parserState->nextKeyword = "";
}
if (parserState->rawKeyword && parserState->rawKeyword->isFinished())
return true;
while (std::getline(*parserState->inputstream, line)) {
// remove comments. note that this is a bit too simplistic as it fails when
// having '--' in strings. _nobody_ does this, though ;)...
int commentPos = line.find("--");
line = line.substr(0, commentPos);
boost::algorithm::trim_right(line); // Removing garbage (eg. \r)
line = doSpecialHandlingForTitleKeyword(line, parserState);
std::string keywordString;
parserState->lineNR++;
// skip empty lines
if (line.size() == 0)
continue;
if (parserState->rawKeyword == NULL) {
if (RawKeyword::isKeywordPrefix(line, keywordString)) {
parserState->rawKeyword = createRawKeyword(keywordString, parserState);
@@ -417,16 +417,22 @@ namespace Opm {
return true;
}
}
if (RawKeyword::useLine(line)) {
parserState->rawKeyword->addRawRecordString(line);
}
parserState->rawKeyword->addRawRecordString(line);
line = "";
}
if (parserState->rawKeyword != NULL && parserState->rawKeyword->isFinished())
if (parserState->rawKeyword
&& parserState->rawKeyword->isFinished()
&& parserState->rawKeyword->getSizeType() != Raw::UNKNOWN)
{
return true;
}
}
if (parserState->rawKeyword && parserState->rawKeyword->getSizeType() == Raw::UNKNOWN)
if (parserState->rawKeyword
&& parserState->rawKeyword->getSizeType() == Raw::UNKNOWN)
{
parserState->rawKeyword->finalizeUnknownSize();
}
return false;
}

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, bool strictParsing=true, ParserLogPtr parserLog = std::make_shared<ParserLog>(&std::cout)) const;
DeckPtr parseString(const std::string &data, bool strictParsing=true, ParserLogPtr parserLog = std::make_shared<ParserLog>(&std::cout)) const;
DeckPtr parseStream(std::shared_ptr<std::istream> inputStream, bool strictParsing=true, 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);

22
opm/parser/eclipse/Parser/ParserDoubleItem.cpp
View File

@@ -39,26 +39,36 @@ namespace Opm
m_default = std::numeric_limits<double>::quiet_NaN();
}
ParserDoubleItem::ParserDoubleItem(const std::string& itemName) : ParserItem(itemName)
ParserDoubleItem::ParserDoubleItem(const std::string& itemName)
: ParserItem(itemName)
{
m_default = std::numeric_limits<double>::quiet_NaN();
m_defaultSet = false;
}
ParserDoubleItem::ParserDoubleItem(const std::string& itemName, double defaultValue) : ParserItem(itemName)
ParserDoubleItem::ParserDoubleItem(const std::string& itemName, double defaultValue)
: ParserItem(itemName)
{
setDefault( defaultValue );
}
ParserDoubleItem::ParserDoubleItem(const std::string& itemName, ParserItemSizeEnum sizeType_, double defaultValue) : ParserItem(itemName, sizeType_)
ParserDoubleItem::ParserDoubleItem(const std::string& itemName, ParserItemSizeEnum sizeType, double defaultValue)
: ParserItem(itemName, sizeType)
{
setDefault( defaultValue );
}
double ParserDoubleItem::getDefault() const {
return m_default;
if (hasDefault())
return m_default;
if (sizeType() == Opm::ALL)
return std::numeric_limits<double>::quiet_NaN();
throw std::invalid_argument("No default value available for item "+name());
}
@@ -67,7 +77,9 @@ namespace Opm
m_defaultSet = true;
}
bool ParserDoubleItem::hasDefault() const {
return m_defaultSet;
}
ParserDoubleItem::ParserDoubleItem(const Json::JsonObject& jsonConfig) :
ParserItem(jsonConfig)

2
opm/parser/eclipse/Parser/ParserDoubleItem.hpp
View File

@@ -51,6 +51,8 @@ namespace Opm {
void inlineNew(std::ostream& os) const;
void setDefault(double defaultValue);
double getDefault() const;
bool hasDefault() const;
size_t dimensionSize() const;
private:

11
opm/parser/eclipse/Parser/ParserFloatItem.cpp
View File

@@ -58,9 +58,18 @@ namespace Opm
float ParserFloatItem::getDefault() const {
return m_default;
if (hasDefault())
return m_default;
if (sizeType() == Opm::ALL)
return std::numeric_limits<float>::quiet_NaN();
throw std::invalid_argument("No default value available for item "+name());
}
bool ParserFloatItem::hasDefault() const {
return m_defaultSet;
}
void ParserFloatItem::setDefault(float defaultValue) {
if (sizeType() == ALL)

1
opm/parser/eclipse/Parser/ParserFloatItem.hpp
View File

@@ -52,6 +52,7 @@ namespace Opm {
void inlineNew(std::ostream& os) const;
void setDefault(float defaultValue);
float getDefault() const;
bool hasDefault() const;
size_t dimensionSize() const;
private:

17
opm/parser/eclipse/Parser/ParserIntItem.cpp
View File

@@ -34,11 +34,14 @@ namespace Opm {
// this is usually meaningless. (Keep in mind that in the deck it can be queried
// using deckItem->defaultApplied(idx) if an item was defaulted or not...
m_default = -1;
m_defaultSet = false;
}
ParserIntItem::ParserIntItem(const std::string& itemName, ParserItemSizeEnum sizeType_) : ParserItem(itemName, sizeType_)
ParserIntItem::ParserIntItem(const std::string& itemName, ParserItemSizeEnum sizeType)
: ParserItem(itemName, sizeType)
{
m_default = -1;
m_defaultSet = false;
}
ParserIntItem::ParserIntItem(const std::string& itemName, int defaultValue) : ParserItem(itemName)
@@ -68,7 +71,17 @@ namespace Opm {
}
int ParserIntItem::getDefault() const {
return m_default;
if (hasDefault())
return m_default;
if (sizeType() == Opm::ALL)
return -1;
throw std::invalid_argument("No default value available for item "+name());
}
bool ParserIntItem::hasDefault() const {
return m_defaultSet;
}
DeckItemPtr ParserIntItem::scan(RawRecordPtr rawRecord) const {

1
opm/parser/eclipse/Parser/ParserIntItem.hpp
View File

@@ -46,6 +46,7 @@ namespace Opm {
void inlineNew(std::ostream& os) const;
int getDefault() const;
bool hasDefault() const;
void setDefault(int defaultValue);
private:
int m_default;

4
opm/parser/eclipse/Parser/ParserItem.cpp
View File

@@ -25,9 +25,9 @@
namespace Opm {
ParserItem::ParserItem(const std::string& itemName, ParserItemSizeEnum sizeType_) {
ParserItem::ParserItem(const std::string& itemName, ParserItemSizeEnum sizeType) {
m_name.assign(itemName);
m_sizeType = sizeType_;
m_sizeType = sizeType;
m_defaultSet = false;
m_description = "";
}

25
opm/parser/eclipse/Parser/ParserItem.hpp
View File

@@ -130,11 +130,17 @@ namespace Opm {
}
}
} else {
if (rawRecord->size() == 0)
// if the record was ended prematurely, use the default value for the
// item...
deckItem->push_backDefault( self->getDefault() );
else {
if (rawRecord->size() == 0) {
// if the record was ended prematurely,
if (self->hasDefault()) {
// use the default value for the item, if there is one...
deckItem->push_backDefault( self->getDefault() );
} else {
// ... otherwise indicate that the deck item should throw once the
// item's data is accessed.
deckItem->push_backDummyDefault();
}
} else {
// The '*' should be interpreted as a repetition indicator, but it must
// be preceeded by an integer...
std::string token = rawRecord->pop_front();
@@ -143,9 +149,12 @@ namespace Opm {
if (isStarToken(token, countString, valueString)) {
StarToken st(token, countString, valueString);
if (!st.hasValue())
deckItem->push_backDefault( self->getDefault() );
else
if (!st.hasValue()) {
if (self->hasDefault())
deckItem->push_backDefault( self->getDefault() );
else
deckItem->push_backDummyDefault();
} else
deckItem->push_back(readValueToken<ValueType>(st.valueString()));
// replace the first occurence of "N*FOO" by a sequence of N-1 times

40
opm/parser/eclipse/Parser/ParserKeyword.cpp
View File

@@ -47,7 +47,7 @@ namespace Opm {
ParserKeyword::ParserKeyword(const std::string& name, ParserKeywordSizeEnum sizeType, ParserKeywordActionEnum action) {
if (!(sizeType == SLASH_TERMINATED || sizeType == UNKNOWN)) {
throw std::invalid_argument("Size type " + ParserKeywordSizeEnum2String(sizeType) + " can not be set explicitly.");
throw std::invalid_argument("Size type " + ParserKeywordSizeEnum2String(sizeType) + " cannot be set explicitly.");
}
commonInit(name, sizeType , action);
}
@@ -131,7 +131,7 @@ namespace Opm {
ParserKeywordSizeEnum sizeType = UNKNOWN;
commonInit(jsonConfig.get_string("name"), sizeType , action);
} else
throw std::invalid_argument("Json object is missing name: property");
throw std::invalid_argument("Json object is missing the 'name' property");
if (jsonConfig.has_item("deck_names") || jsonConfig.has_item("deck_name_regex") )
// if either the deck names or the regular expression for deck names are
@@ -158,7 +158,7 @@ namespace Opm {
return;
else {
if (numItems() == 0)
throw std::invalid_argument("Json object for keyword: " + jsonConfig.get_string("name") + " is missing items specifier");
throw std::invalid_argument("Json object for keyword "+getName()+" is missing the 'items' property");
}
}
@@ -269,20 +269,20 @@ namespace Opm {
void ParserKeyword::addItem(ParserItemConstPtr item) {
if (m_isDataKeyword)
throw std::invalid_argument("Keyword:" + getName() + " is already configured as data keyword - can not add more items.");
throw std::invalid_argument("Keyword " + getName() + " is already configured as a data keyword; cannot add items.");
m_record->addItem(item);
}
void ParserKeyword::addDataItem(ParserItemConstPtr item) {
if (m_record->size())
throw std::invalid_argument("Keyword:" + getName() + " already has items - can not add a data item.");
throw std::invalid_argument("Keyword " + getName() + " already contains all specified items; cannot add a data item.");
if ((m_keywordSizeType == FIXED) && (m_fixedSize == 1U)) {
addItem(item);
m_isDataKeyword = true;
} else
throw std::invalid_argument("Keyword:" + getName() + ". When calling addDataItem() the keyword must be configured with fixed size == 1.");
throw std::invalid_argument("When calling addDataItem() for keyword " + getName() + ", it must be configured with fixed size == 1.");
}
void ParserKeyword::initDeckNames(const Json::JsonObject& jsonObject) {
@@ -291,7 +291,7 @@ namespace Opm {
const Json::JsonObject namesObject = jsonObject.get_item("deck_names");
if (!namesObject.is_array())
throw std::invalid_argument("The 'deck_names' JSON item needs to be a list (keyword: '"+m_name+"')");
throw std::invalid_argument("The 'deck_names' JSON item of keyword "+m_name+" needs to be a list");
if (namesObject.size() > 0)
m_deckNames.clear();
@@ -300,7 +300,7 @@ namespace Opm {
const Json::JsonObject nameObject = namesObject.get_array_item(nameIdx);
if (!nameObject.is_string())
throw std::invalid_argument("The items of 'deck_names' need to be strings (keyword: '"+m_name+"')");
throw std::invalid_argument("The sub-items of 'deck_names' of keyword "+m_name+" need to be strings");
addDeckName(nameObject.as_string());
}
@@ -308,19 +308,19 @@ namespace Opm {
void ParserKeyword::initSectionNames(const Json::JsonObject& jsonObject) {
if (!jsonObject.has_item("sections"))
throw std::invalid_argument("The 'sections' JSON item needs to be defined (keyword: '"+m_name+"')");
throw std::invalid_argument("The 'sections' JSON item of keyword "+m_name+" needs to be defined");
const Json::JsonObject namesObject = jsonObject.get_item("sections");
if (!namesObject.is_array())
throw std::invalid_argument("The 'sections' JSON item needs to be a list (keyword: '"+m_name+"')");
throw std::invalid_argument("The 'sections' JSON item of keyword "+m_name+" needs to be a list");
m_validSectionNames.clear();
for (size_t nameIdx = 0; nameIdx < namesObject.size(); ++ nameIdx) {
const Json::JsonObject nameObject = namesObject.get_array_item(nameIdx);
if (!nameObject.is_string())
throw std::invalid_argument("The items of 'sections' need to be strings (keyword: '"+m_name+"')");
throw std::invalid_argument("The sub-items of 'sections' of keyword "+m_name+" need to be strings");
addValidSectionName(nameObject.as_string());
}
@@ -332,7 +332,7 @@ namespace Opm {
const Json::JsonObject regexStringObject = jsonObject.get_item("deck_name_regex");
if (!regexStringObject.is_string())
throw std::invalid_argument("The 'deck_name_regex' JSON item needs to be a string (keyword: '"+m_name+"')");
throw std::invalid_argument("The 'deck_name_regex' JSON item of keyword "+m_name+" need to be a string");
setMatchRegex(regexStringObject.as_string());
}
@@ -374,13 +374,13 @@ namespace Opm {
}
break;
default:
throw std::invalid_argument("Not implemented.");
throw std::invalid_argument("While parsing "+getName()+": Values of type "+itemConfig.get_string("value_type")+" are not implemented.");
}
} else
throw std::invalid_argument("Json config object missing \"value_type\": ... item");
throw std::invalid_argument("'value_type' JSON item missing for keyword "+getName()+".");
}
} else
throw std::invalid_argument("The items: object must be an array");
throw std::invalid_argument("The 'items' JSON item missing must be an array in keyword "+getName()+".");
}
@@ -395,7 +395,7 @@ namespace Opm {
item->push_backDimension( dimObject.as_string());
}
} else
throw std::invalid_argument("The dimension: attribute must be a string/list of strings");
throw std::invalid_argument("The 'dimension' attribute of keyword "+getName()+" must be a string or a list of strings");
}
}
@@ -411,7 +411,7 @@ namespace Opm {
item->push_backDimension( dimObject.as_string());
}
} else
throw std::invalid_argument("The dimension: attribute must be a string/list of strings");
throw std::invalid_argument("The 'dimension' attribute of keyword "+getName()+" must be a string or a list of strings");
}
}
@@ -471,10 +471,10 @@ namespace Opm {
}
break;
default:
throw std::invalid_argument("Not implemented.");
throw std::invalid_argument("While initializing keyword "+getName()+": Values of type "+dataConfig.get_string("value_type")+" are not implemented.");
}
} else
throw std::invalid_argument("Json config object missing \"value_type\": ... item");
throw std::invalid_argument("The 'value_type' JSON item of keyword "+getName()+" is missing");
}
ParserRecordPtr ParserKeyword::getRecord() const {
@@ -525,11 +525,11 @@ namespace Opm {
if (rawKeyword->isFinished()) {
DeckKeywordPtr keyword(new DeckKeyword(rawKeyword->getKeywordName()));
keyword->setLocation(rawKeyword->getFilename(), rawKeyword->getLineNR());
keyword->setDataKeyword( isDataKeyword() );
for (size_t i = 0; i < rawKeyword->size(); i++) {
DeckRecordConstPtr deckRecord = m_record->parse(rawKeyword->getRecord(i));
keyword->addRecord(deckRecord);
}
keyword->setDataKeyword( isDataKeyword() );
return keyword;
} else
throw std::invalid_argument("Tried to create a deck keyword from an incomplete raw keyword " + rawKeyword->getKeywordName());

4
opm/parser/eclipse/Parser/ParserKeyword.hpp
View File

@@ -172,8 +172,8 @@ namespace Opm {
void initSizeKeyword(const Json::JsonObject& sizeObject);
void commonInit(const std::string& name, ParserKeywordSizeEnum sizeType , ParserKeywordActionEnum action);
void addItems( const Json::JsonObject& jsonConfig);
static void initDoubleItemDimension( ParserDoubleItemPtr item, const Json::JsonObject itemConfig);
static void initFloatItemDimension( ParserFloatItemPtr item, const Json::JsonObject itemConfig);
void initDoubleItemDimension( ParserDoubleItemPtr item, const Json::JsonObject itemConfig);
void initFloatItemDimension( ParserFloatItemPtr item, const Json::JsonObject itemConfig);
};
}

14
opm/parser/eclipse/Parser/ParserStringItem.cpp
View File

@@ -27,12 +27,14 @@ namespace Opm {
ParserStringItem::ParserStringItem(const std::string& itemName) : ParserItem(itemName)
{
m_default = "";
m_defaultSet = false;
}
ParserStringItem::ParserStringItem(const std::string& itemName, ParserItemSizeEnum sizeType_) : ParserItem(itemName, sizeType_)
{
m_default = "";
m_defaultSet = false;
}
ParserStringItem::ParserStringItem(const std::string& itemName, ParserItemSizeEnum sizeType_, const std::string& defaultValue) : ParserItem(itemName, sizeType_) {
@@ -62,10 +64,18 @@ namespace Opm {
}
std::string ParserStringItem::getDefault() const {
return m_default;
if (hasDefault())
return m_default;
if (sizeType() == Opm::ALL)
return "";
throw std::invalid_argument("No default value available for item "+name());
}
bool ParserStringItem::hasDefault() const {
return m_defaultSet;
}
DeckItemPtr ParserStringItem::scan(RawRecordPtr rawRecord) const {
return ParserItemScan<ParserStringItem,DeckStringItem,std::string>(this , rawRecord);

1
opm/parser/eclipse/Parser/ParserStringItem.hpp
View File

@@ -43,6 +43,7 @@ namespace Opm {
void inlineNew(std::ostream& os) const;
void setDefault(const std::string& defaultValue);
std::string getDefault() const;
bool hasDefault() const;
private:
std::string m_default;

7
opm/parser/eclipse/Parser/createDefaultKeywordList.cpp
View File

@@ -215,9 +215,10 @@ static void scanKeyword(const boost::filesystem::path& file , KeywordMapType& ke
Json::JsonObject * jsonKeyword;
try {
jsonKeyword = new Json::JsonObject(file);
} catch(...) {
std::cerr << "Parsing json config file: " << file.string() << " failed - keyword skipped." << std::endl;
return;
} catch(const std::exception& e) {
std::cerr << "Parsing JSON keyword definition from file '" << file.string() << "' failed: "
<< e.what() << "\n";
std::exit(1);
}
{

26
opm/parser/eclipse/Parser/tests/ParserItemTests.cpp
View File

@@ -71,7 +71,9 @@ BOOST_AUTO_TEST_CASE(Initialize_DefaultSizeType) {
BOOST_AUTO_TEST_CASE(Initialize_Default) {
ParserIntItem item1(std::string("ITEM1"));
ParserIntItem item2(std::string("ITEM1"), 88);
BOOST_CHECK(item1.getDefault() < 0);
BOOST_CHECK(!item1.hasDefault());
BOOST_CHECK_THROW(item1.getDefault(), std::invalid_argument);
BOOST_CHECK(item2.hasDefault());
BOOST_CHECK_EQUAL(item2.getDefault(), 88);
}
@@ -79,37 +81,41 @@ BOOST_AUTO_TEST_CASE(Initialize_Default) {
BOOST_AUTO_TEST_CASE(Initialize_Default_Double) {
ParserDoubleItem item1(std::string("ITEM1"));
ParserDoubleItem item2("ITEM1", 88.91);
BOOST_CHECK(!std::isfinite(item1.getDefault()));
BOOST_CHECK(!item1.hasDefault());
BOOST_CHECK_THROW(item1.getDefault(), std::invalid_argument);
BOOST_CHECK_EQUAL( 88.91 , item2.getDefault());
}
BOOST_AUTO_TEST_CASE(Initialize_Default_Float) {
ParserFloatItem item1(std::string("ITEM1"));
ParserFloatItem item2("ITEM1", 88.91F);
BOOST_CHECK(!std::isfinite(item1.getDefault()));
BOOST_CHECK(!item1.hasDefault());
BOOST_CHECK_THROW(item1.getDefault(), std::invalid_argument);
BOOST_CHECK(item2.hasDefault());
BOOST_CHECK_EQUAL( 88.91F , item2.getDefault());
}
BOOST_AUTO_TEST_CASE(Initialize_Default_String) {
ParserStringItem item1(std::string("ITEM1"));
BOOST_CHECK(item1.getDefault() == "");
BOOST_CHECK(!item1.hasDefault());
BOOST_CHECK_THROW(item1.getDefault(), std::invalid_argument);
ParserStringItem item2("ITEM1", "String");
BOOST_CHECK(item2.hasDefault());
BOOST_CHECK_EQUAL( "String" , item2.getDefault());
}
BOOST_AUTO_TEST_CASE(scan_PreMatureTerminator_defaultUsed) {
ParserIntItem itemInt(std::string("ITEM2"));
ParserIntItem itemInt(std::string("ITEM2"), 123);
RawRecordPtr rawRecord1(new RawRecord("/"));
DeckItemConstPtr defaulted = itemInt.scan(rawRecord1);
// an item is always present even if the record was ended. If the deck specified no
// data and the item does not have a meaningful default, the item gets assigned a NaN
// (for float and double items), -1 (for integer items) and "" (for string items)
// whit the defaultApplied(0) method returning true...
BOOST_CHECK(defaulted->defaultApplied(0));
BOOST_CHECK(defaulted->getInt(0) < 0);
BOOST_CHECK_EQUAL(defaulted->getInt(0), 123);
}
BOOST_AUTO_TEST_CASE(InitializeIntItem_setDescription_canReadBack) {

9
opm/parser/eclipse/Parser/tests/ParserRecordTests.cpp
View File

@@ -315,7 +315,7 @@ BOOST_AUTO_TEST_CASE(Parse_RawRecordTooManyItems_Throws) {
}
BOOST_AUTO_TEST_CASE(Parse_RawRecordTooFewItems_ThrowsNot) {
BOOST_AUTO_TEST_CASE(Parse_RawRecordTooFewItems) {
ParserRecordPtr parserRecord(new ParserRecord());
ParserIntItemConstPtr itemI(new ParserIntItem("I", SINGLE));
ParserIntItemConstPtr itemJ(new ParserIntItem("J", SINGLE));
@@ -326,7 +326,12 @@ BOOST_AUTO_TEST_CASE(Parse_RawRecordTooFewItems_ThrowsNot) {
parserRecord->addItem(itemK);
RawRecordPtr rawRecord(new RawRecord("3 3 /"));
BOOST_CHECK_NO_THROW(parserRecord->parse(rawRecord));
// no default specified for the third item, record can be parsed just fine but trying
// to access the data will raise an exception...
DeckRecordConstPtr record;
BOOST_CHECK_NO_THROW(record = parserRecord->parse(rawRecord));
BOOST_CHECK_NO_THROW(record->getItem(2));
BOOST_CHECK_THROW(record->getItem(2)->getInt(0), std::out_of_range);
}

35
opm/parser/eclipse/RawDeck/RawKeyword.cpp
View File

@@ -85,7 +85,7 @@ namespace Opm {
m_isFinished = true;
m_partialRecordString.clear();
}
} else {
} else if (m_sizeType != Raw::UNKNOWN) {
m_isFinished = true;
m_partialRecordString.clear();
}
@@ -121,45 +121,18 @@ namespace Opm {
throw std::range_error("Index out of range");
}
bool RawKeyword::isKeywordPrefix(const std::string& keywordCandidate, std::string& result) {
// get rid of comments
size_t commentPos = keywordCandidate.find("--");
if (commentPos != std::string::npos)
result = keywordCandidate.substr(0, commentPos);
else
result = keywordCandidate;
// white space is for dicks!
result = boost::trim_right_copy_if(result.substr(0, 8), boost::is_any_of(" \t"));
bool RawKeyword::isKeywordPrefix(const std::string& line, std::string& keywordName) {
// make the keyword string ALL_UPPERCASE because Eclipse seems
// to be case-insensitive (although this is one of its
// undocumented features...)
boost::to_upper(result);
if (isValidKeyword(result))
return true;
else
return false;
keywordName = boost::to_upper_copy(ParserKeyword::getDeckName(line));
return isValidKeyword(keywordName);
}
bool RawKeyword::isValidKeyword(const std::string& keywordCandidate) {
return ParserKeyword::validDeckName(keywordCandidate);
}
bool RawKeyword::useLine(std::string line) {
boost::algorithm::trim_left(line);
if (line.length()) {
if (line.substr(0,2) == "--")
return false;
else
return true;
} else
return false;
}
void RawKeyword::setKeywordName(const std::string& name) {
m_name = boost::algorithm::trim_right_copy(name);
if (!isValidKeyword(m_name)) {

1
opm/parser/eclipse/RawDeck/RawKeyword.hpp
View File

@@ -48,7 +48,6 @@ namespace Opm {
static bool isKeywordPrefix(const std::string& line, std::string& keywordName);
static bool isTerminator(std::string line);
static bool useLine(std::string line);
bool isPartialRecordStringEmpty() const;

11
opm/parser/eclipse/RawDeck/tests/RawKeywordTests.cpp
View File

@@ -157,17 +157,6 @@ BOOST_AUTO_TEST_CASE(isKeywordTerminator) {
BOOST_CHECK( !RawKeyword::isTerminator(" X/ "));
}
BOOST_AUTO_TEST_CASE(useLine) {
BOOST_CHECK( !RawKeyword::useLine(" "));
BOOST_CHECK( !RawKeyword::useLine("-- ggg"));
BOOST_CHECK( RawKeyword::useLine("Data -- ggg"));
BOOST_CHECK( RawKeyword::useLine("/ -- ggg"));
BOOST_CHECK( RawKeyword::useLine("/"));
}
BOOST_AUTO_TEST_CASE(isTableCollection) {
RawKeyword keyword1("TEST" , "FILE" , 10U, 4U , false);
RawKeyword keyword2("TEST2", Raw::SLASH_TERMINATED , "FILE" , 10U);

2
opm/parser/eclipse/Units/ConversionFactors.hpp
View File

@@ -198,6 +198,7 @@ namespace Opm {
const double Time = day;
const double Mass = kilogram;
const double Permeability = milli*darcy;
const double Transmissibility = centi*Poise*cubic(meter)/(day*barsa);
const double LiquidVolume = cubic(meter);
const double GasVolume = cubic(meter);
const double GasDissolutionFactor = GasVolume/LiquidVolume;
@@ -219,6 +220,7 @@ namespace Opm {
const double Time = day;
const double Mass = pound;
const double Permeability = milli*darcy;
const double Transmissibility = centi*Poise*stb/(day*psia);
const double LiquidVolume = stb;
const double GasVolume = 1000*cubic(feet);
const double GasDissolutionFactor = GasVolume/LiquidVolume;

2
opm/parser/eclipse/Units/UnitSystem.cpp
View File

@@ -154,6 +154,7 @@ namespace Opm {
system->addDimension("Time" , Metric::Time );
system->addDimension("Mass" , Metric::Mass );
system->addDimension("Permeability", Metric::Permeability );
system->addDimension("Transmissibility", Metric::Transmissibility );
system->addDimension("GasDissolutionFactor", Metric::GasDissolutionFactor);
system->addDimension("OilDissolutionFactor", Metric::OilDissolutionFactor);
system->addDimension("LiquidVolume", Metric::LiquidVolume );
@@ -178,6 +179,7 @@ namespace Opm {
system->addDimension("Time" , Field::Time);
system->addDimension("Mass", Field::Mass);
system->addDimension("Permeability", Field::Permeability );
system->addDimension("Transmissibility", Field::Transmissibility );
system->addDimension("GasDissolutionFactor" , Field::GasDissolutionFactor);
system->addDimension("OilDissolutionFactor", Field::OilDissolutionFactor);
system->addDimension("LiquidVolume", Field::LiquidVolume );

6
opm/parser/share/keywords/000_Eclipse100/A/ADDREG Normal file
View File

@@ -0,0 +1,6 @@
{"name" : "ADDREG" , "sections" : ["GRID","EDIT","PROPS","REGIONS","SOLUTION"],
"items" :
[{"name" : "ARRAY" , "value_type" : "STRING" , "description" : "The 3D array we will update"},
{"name" : "SHIFT" , "value_type" : "DOUBLE" , "description" : "The value we will multiply with" , "default" : 0} ,
{"name" : "REGION_NUMBER" , "value_type" : "INT" , "description" : "The region number we are interested in"} ,
{"name" : "REGION_NAME" , "value_type" : "STRING" , "description" : "The name of the region we are interested in" , "default" : "M"}]}

6
opm/parser/share/keywords/000_Eclipse100/C/COPYREG Normal file
View File

@@ -0,0 +1,6 @@
{"name" : "COPYREG" , "sections" : ["GRID","EDIT","PROPS","REGIONS","SOLUTION"],
"items" :
[{"name" : "ARRAY" , "value_type" : "STRING" , "description" : "The 3D array we will update"},
{"name" : "TARGET_ARRAY" , "value_type" : "STRING" , "description" : "The name of the array which will be set"} ,
{"name" : "REGION_NUMBER" , "value_type" : "INT" , "description" : "The region number we are interested in"} ,
{"name" : "REGION_NAME" , "value_type" : "STRING" , "description" : "The name of the region we are interested in" , "default" : "M"}]}

2
opm/parser/share/keywords/000_Eclipse100/E/EHYSTR
View File

@@ -7,7 +7,7 @@
{"name" : "limiting_hyst_flag", "value_type" : "STRING", "default" : "BOTH"},
{"name" : "shape_cap_press_flag", "value_type" : "STRING", "default" : "RETR"},
{"name" : "init_fluid_mob_flag", "value_type" : "STRING", "default" : "DRAIN"},
{"name" : "wetting_phase_flag", "value_type" : "STRING"},
{"name" : "wetting_phase_flag", "value_type" : "STRING" , "default" : "OIL"},
{"name" : "baker_flag_oil", "value_type" : "STRING", "default" : "NO"},
{"name" : "baker_flag_gas", "value_type" : "STRING", "default" : "NO"},
{"name" : "baker_flag_water", "value_type" : "STRING", "default" : "NO"},

6
opm/parser/share/keywords/000_Eclipse100/E/EQUALREG Normal file
View File

@@ -0,0 +1,6 @@
{"name" : "EQUALREG" , "sections" : ["GRID","EDIT","PROPS","REGIONS","SOLUTION"],
"items" :
[{"name" : "ARRAY" , "value_type" : "STRING" , "description" : "The 3D array we will update"},
{"name" : "VALUE" , "value_type" : "DOUBLE" , "description" : "The value we will assign" , "default" : 0} ,
{"name" : "REGION_NUMBER" , "value_type" : "INT" , "description" : "The region number we are interested in"} ,
{"name" : "REGION_NAME" , "value_type" : "STRING" , "description" : "The name of the region we are interested in" , "default" : "M"}]}

6
opm/parser/share/keywords/000_Eclipse100/M/MULTIREG Normal file
View File

@@ -0,0 +1,6 @@
{"name" : "MULTIREG" , "sections" : ["GRID","EDIT","PROPS","REGIONS","SOLUTION"],
"items" :
[{"name" : "ARRAY" , "value_type" : "STRING" , "description" : "The 3D array we will update"},
{"name" : "FACTOR" , "value_type" : "DOUBLE" , "description" : "The value we will multiply with" , "default" : 0} ,
{"name" : "REGION_NUMBER" , "value_type" : "INT" , "description" : "The region number we are interested in"} ,
{"name" : "REGION_NAME" , "value_type" : "STRING" , "description" : "The name of the region we are interested in" , "default" : "M"}]}

52
opm/parser/share/keywords/000_Eclipse100/N/NNC Normal file
View File

@@ -0,0 +1,52 @@
{
"name": "NNC",
"sections": ["GRID"],
"items": [
{"name": "I1", "value_type": "INT"},
{"name": "J1", "value_type": "INT"},
{"name": "K1", "value_type": "INT"},
{"name": "I2", "value_type": "INT"},
{"name": "J2", "value_type": "INT"},
{"name": "K2", "value_type": "INT"},
{"name": "TRAN",
"value_type": "DOUBLE",
"dimension": "Transmissibility",
"default": 0.0 },
{"name": "SIM_DEPENDENT1",
"value_type": "DOUBLE",
"dimension": "ContextDependent",
"default": 0.0 },
{"name": "SIM_DEPENDENT2",
"comment": "This item is deprecated",
"value_type": "DOUBLE",
"dimension": "ContextDependent",
"default": 0.0 },
{"name": "PRESSURE_TABLE1",
"value_type": "INT",
"default": 0 },
{"name": "PRESSURE_TABLE2",
"value_type": "INT",
"default": 0 },
{"name": "VE_FACE1",
"value_type": "STRING",
"default": "" },
{"name": "VE_FACE2",
"value_type": "STRING",
"default": "" },
{"name": "DIFFUSIVITY",
"value_type": "DOUBLE",
"default": 0.0 },
{"name": "SIM_DEPENDENT3",
"value_type": "DOUBLE",
"dimension": "ContextDependent",
"default": 0.0 },
{"name": "VDFLOW_AREA",
"value_type": "DOUBLE",
"dimension": "Length*Length",
"default": 0.0 },
{"name": "VDFLOW_PERM",
"value_type": "DOUBLE",
"dimension": "Permeability",
"default": 0.0 }
]
}

8
opm/parser/share/keywords/000_Eclipse100/T/TRANX Normal file
View File

@@ -0,0 +1,8 @@
{
"name": "TRANX",
"sections": ["EDIT"],
"data": {
"value_type": "DOUBLE",
"dimension" : "Transmissibility"
}
}

8
opm/parser/share/keywords/000_Eclipse100/T/TRANY Normal file
View File

@@ -0,0 +1,8 @@
{
"name": "TRANY",
"sections": ["EDIT"],
"data": {
"value_type": "DOUBLE",
"dimension" : "Transmissibility"
}
}

8
opm/parser/share/keywords/000_Eclipse100/T/TRANZ Normal file
View File

@@ -0,0 +1,8 @@
{
"name": "TRANZ",
"sections": ["EDIT"],
"data": {
"value_type": "DOUBLE",
"dimension" : "Transmissibility"
}
}

2
opm/parser/share/keywords/000_Eclipse100/W/WTRACER
View File

@@ -3,4 +3,4 @@
{"name" : "TRACER" , "value_type" : "STRING"},
{"name" : "CONCENTRATION" , "value_type" : "DOUBLE"},
{"name" : "CUM_TRACER_FACTOR" , "value_type" : "DOUBLE"},
{"name" : "PRODUCTION_GROUP" , "value_type" : "STRING"}]}
{"name" : "PRODUCTION_GROUP" , "value_type" : "STRING" , "comment" : "Defaulted means: use the concentration from the CONCENTRATION item"}]}

4
testdata/integration_tests/ACTION/ACTION.txt vendored
View File

@@ -1,8 +1,4 @@
UNRECOGNIZED
This Keyword should give a warning at line 2/
DIMENS -- /This is flagged as IGNORE_WARNING - and should give a warning at line: 6
10 10 10 /

2
testdata/integration_tests/SCHEDULE/SCHEDULE_COMPDAT1 vendored
View File

@@ -54,6 +54,6 @@ COMPDAT
'W_3' 31 18 2 2 'OPEN' 1* 55.195 0.311 4923.842 2* 'Y' 18.524 /
'W_3' 31 18 3 3 'OPEN' 1* 18.032 0.311 1608.615 2* 'Y' 18.526 /
'W_3' 31 17 3 3 'OPEN' 1* 56.817 0.311 5047.177 2* 'Y' 18.155 /
'W_3' 31 17 4 4 'OPEN' 1* 4.728 0.311 420.067 2* 'Y' 18.162 /
'W_3' 31 17 4 4 'OPEN' 1* 4.728 1* 420.067 2* 'Y' 18.162 /
/

5
testdata/integration_tests/truncated_records.data vendored
View File

@@ -5,9 +5,6 @@ RADFIN4
'NAME' 213 123 123 123 7 7 18 18 18 18 /
RADFIN4
'NAME' 213 /
RADFIN4
/
'NAME' 213 123 123 123 7 7 18 18 18 /