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

Add Location member to SummaryNode instances

Browse Source
This commit is contained in:
Joakim Hove
2019-11-07 12:03:38 +01:00
parent a3090fd88f
commit f17eefcaf7
3 changed files with 66 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.hpp
View File

@@ -26,6 +26,8 @@
#include <string>
#include <vector>
#include <opm/common/OpmLog/Location.hpp>
namespace Opm {
/*
@@ -48,7 +50,7 @@ namespace Opm {
Undefined,
};
explicit SummaryNode(std::string keyword, const Category cat);
explicit SummaryNode(std::string keyword, const Category cat, Location loc_arg);
SummaryNode& parameterType(const Type type);
SummaryNode& namedEntity(std::string name);
@@ -63,10 +65,11 @@ namespace Opm {
bool isUserDefined() const { return this->userDefined_; }
std::string uniqueNodeKey() const;
const Location& location( ) const { return this->loc; }
private:
std::string keyword_;
Category category_;
Location loc;
Type type_{ Type::Undefined };
std::string name_{};
int number_{std::numeric_limits<int>::min()};

29
src/opm/output/eclipse/Summary.cpp
View File

@@ -21,6 +21,7 @@
#include <opm/output/eclipse/Summary.hpp>
#include <opm/common/OpmLog/OpmLog.hpp>
#include <opm/common/OpmLog/Location.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Eclipse3DProperties.hpp>
@@ -124,7 +125,7 @@ namespace {
const std::string& name) -> void
{
for (const auto& vector : vectors) {
entities.emplace_back(kwpref + vector.kw, cat);
entities.emplace_back(kwpref + vector.kw, cat, Location());
entities.back().namedEntity(name)
.parameterType(vector.type);
@@ -134,15 +135,15 @@ namespace {
for (const auto& well_name : sched.wellNames()) {
makeEntities('W', SN::Category::Well, well_name);
entities.emplace_back("WBHP", SN::Category::Well);
entities.emplace_back("WBHP", SN::Category::Well, Location());
entities.back().namedEntity(well_name)
.parameterType(SN::Type::Pressure);
entities.emplace_back("WGVIR", SN::Category::Well);
entities.emplace_back("WGVIR", SN::Category::Well, Location());
entities.back().namedEntity(well_name)
.parameterType(SN::Type::Rate);
entities.emplace_back("WWVIR", SN::Category::Well);
entities.emplace_back("WWVIR", SN::Category::Well, Location());
entities.back().namedEntity(well_name)
.parameterType(SN::Type::Rate);
}
@@ -163,16 +164,16 @@ namespace {
using SN = Opm::SummaryNode;
auto ret = std::vector<SN>{};
auto sofr = SN{ "SOFR", SN::Category::Segment }
auto sofr = SN{ "SOFR", SN::Category::Segment, Location() }
.parameterType(SN::Type::Rate);
auto sgfr = SN{ "SGFR", SN::Category::Segment }
auto sgfr = SN{ "SGFR", SN::Category::Segment, Location() }
.parameterType(SN::Type::Rate);
auto swfr = SN{ "SWFR", SN::Category::Segment }
auto swfr = SN{ "SWFR", SN::Category::Segment, Location() }
.parameterType(SN::Type::Rate);
auto spr = SN{ "SPR", SN::Category::Segment }
auto spr = SN{ "SPR", SN::Category::Segment, Location() }
.parameterType(SN::Type::Pressure);
auto makeVectors =
@@ -1790,13 +1791,15 @@ namespace Evaluator {
}
} // namespace Evaluator
void reportUnsupportedKeywords(std::vector<std::string> keywords)
void reportUnsupportedKeywords(std::vector<Opm::SummaryNode> keywords)
{
std::sort(keywords.begin(), keywords.end());
auto uend = std::unique(keywords.begin(), keywords.end());
for (auto kw = keywords.begin(); kw != uend; ++kw)
::Opm::OpmLog::info("Summary keyword '" + *kw + "' is unhandled");
for (auto node = keywords.begin(); node != uend; ++node) {
const auto& location = node->location();
::Opm::OpmLog::warning("Unhandled summary keyword '" + node->keyword() + "' at " + location.filename + ", line " + std::to_string(location.lineno));
}
}
std::string makeWGName(std::string name)
@@ -2196,13 +2199,13 @@ configureSummaryInput(const EclipseState& es,
es, grid, st, sched.getUDQConfig(sched.size() - 1)
};
auto unsuppkw = std::vector<std::string>{};
auto unsuppkw = std::vector<SummaryNode>{};
for (const auto& node : sumcfg) {
auto prmDescr = fact.create(node);
if (! prmDescr.evaluator) {
// No known evaluation function/type for this keyword
unsuppkw.push_back(node.keyword());
unsuppkw.push_back(node);
continue;
}

98
src/opm/parser/eclipse/EclipseState/SummaryConfig/SummaryConfig.cpp
View File

@@ -88,7 +88,10 @@ namespace {
'PERFORMA', where only the keywords in the expanded list should
be included.
*/
const std::set<std::string> meta_keywords = {"PERFORMA" , "ALL" , "FMWSET", "GMWSET"};
const std::map<std::string, std::vector<std::string>> meta_keywords = {{"PERFORMA", PERFORMA_keywords},
{"ALL", ALL_keywords},
{"FMWSET", FMWSET_keywords},
{"GMWSET", GMWSET_keywords}};
/*
This is a hardcoded mapping between 3D field keywords,
@@ -249,9 +252,10 @@ inline void keywordW( SummaryConfig::keyword_list& list,
inline void keywordW( SummaryConfig::keyword_list& list,
const std::string& keyword,
Location loc,
const Schedule& schedule) {
auto param = SummaryNode {
keyword, SummaryNode::Category::Well
keyword, SummaryNode::Category::Well , std::move(loc)
}
.parameterType( parseKeywordType(keyword) )
.isUserDefined( is_udq(keyword) );
@@ -278,14 +282,15 @@ inline void keywordW( SummaryConfig::keyword_list& list,
*/
if (keyword.name().back() == 'L') {
if (!is_udq(keyword.name())) {
std::string msg = std::string("The completion keywords like: " + keyword.name() + " are not supported");
const auto& location = keyword.location();
std::string msg = std::string("The completion keywords like: " + keyword.name() + " are not supported at: " + location.filename + ", line " + std::to_string(location.lineno));
parseContext.handleError( ParseContext::SUMMARY_UNHANDLED_KEYWORD, msg, errors);
return;
}
}
auto param = SummaryNode {
keyword.name(), SummaryNode::Category::Well
keyword.name(), SummaryNode::Category::Well, keyword.location()
}
.parameterType( parseKeywordType(keyword.name()) )
.isUserDefined( is_udq(keyword.name()) );
@@ -305,9 +310,10 @@ inline void keywordW( SummaryConfig::keyword_list& list,
inline void keywordG( SummaryConfig::keyword_list& list,
const std::string& keyword,
Location loc,
const Schedule& schedule ) {
auto param = SummaryNode {
keyword, SummaryNode::Category::Group
keyword, SummaryNode::Category::Group, std::move(loc)
}
.parameterType( parseKeywordType(keyword) )
.isUserDefined( is_udq(keyword) );
@@ -328,7 +334,7 @@ inline void keywordG( SummaryConfig::keyword_list& list,
if( keyword.name() == "GMWSET" ) return;
auto param = SummaryNode {
keyword.name(), SummaryNode::Category::Group
keyword.name(), SummaryNode::Category::Group, keyword.location()
}
.parameterType( parseKeywordType(keyword.name()) )
.isUserDefined( is_udq(keyword.name()) );
@@ -354,9 +360,10 @@ inline void keywordG( SummaryConfig::keyword_list& list,
}
inline void keywordF( SummaryConfig::keyword_list& list,
const std::string& keyword ) {
const std::string& keyword,
Location loc) {
auto param = SummaryNode {
keyword, SummaryNode::Category::Field
keyword, SummaryNode::Category::Field, std::move(loc)
}
.parameterType( parseKeywordType(keyword) )
.isUserDefined( is_udq(keyword) );
@@ -367,7 +374,7 @@ inline void keywordF( SummaryConfig::keyword_list& list,
inline void keywordF( SummaryConfig::keyword_list& list,
const DeckKeyword& keyword ) {
if( keyword.name() == "FMWSET" ) return;
keywordF( list, keyword.name() );
keywordF( list, keyword.name(), keyword.location() );
}
inline std::array< int, 3 > getijk( const DeckRecord& record,
@@ -388,7 +395,7 @@ inline void keywordB( SummaryConfig::keyword_list& list,
const DeckKeyword& keyword,
const GridDims& dims) {
auto param = SummaryNode {
keyword.name(), SummaryNode::Category::Block
keyword.name(), SummaryNode::Category::Block, keyword.location()
}
.parameterType( parseKeywordType(keyword.name()) )
.isUserDefined( is_udq(keyword.name()) );
@@ -405,15 +412,16 @@ inline void keywordR2R( SummaryConfig::keyword_list& /* list */,
ErrorGuard& errors,
const DeckKeyword& keyword)
{
std::string msg = "OPM/flow does not support region to region summary keywords - " + keyword.name() + " is ignored.";
const auto& location = keyword.location();
std::string msg = "Region to region summary keyword: " + keyword.name() + " at " + location.filename + ", line " + std::to_string(location.lineno) + " is ignored";
parseContext.handleError(ParseContext::SUMMARY_UNHANDLED_KEYWORD, msg, errors);
}
inline void keywordR( SummaryConfig::keyword_list& list,
const DeckKeyword& keyword,
const TableManager& tables,
const ParseContext& parseContext,
const DeckKeyword& keyword,
const TableManager& tables,
const ParseContext& parseContext,
ErrorGuard& errors ) {
/* RUNSUM is not a region keyword but a directive for how to format and
@@ -441,7 +449,7 @@ inline void keywordR2R( SummaryConfig::keyword_list& /* list */,
// Don't (currently) need parameter type for region keywords
auto param = SummaryNode {
keyword.name(), SummaryNode::Category::Region
keyword.name(), SummaryNode::Category::Region, keyword.location()
}
.isUserDefined( is_udq(keyword.name()) );
@@ -455,17 +463,17 @@ inline void keywordR2R( SummaryConfig::keyword_list& /* list */,
inline void keywordMISC( SummaryConfig::keyword_list& list,
const std::string& keyword)
const std::string& keyword,
Location loc)
{
if (meta_keywords.count( keyword ) == 0)
list.emplace_back( keyword, SummaryNode::Category::Miscellaneous );
if (meta_keywords.count(keyword) == 0)
list.emplace_back( keyword, SummaryNode::Category::Miscellaneous , std::move(loc));
}
inline void keywordMISC( SummaryConfig::keyword_list& list,
const DeckKeyword& keyword)
{
keywordMISC( list, keyword.name() );
keywordMISC(list, keyword.name(), keyword.location());
}
inline void keywordC( SummaryConfig::keyword_list& list,
@@ -476,7 +484,7 @@ inline void keywordMISC( SummaryConfig::keyword_list& list,
const GridDims& dims) {
auto param = SummaryNode {
keyword.name(), SummaryNode::Category::Connection
keyword.name(), SummaryNode::Category::Connection, keyword.location()
}
.parameterType( parseKeywordType( keyword.name()) )
.isUserDefined( is_udq(keyword.name()) );
@@ -551,7 +559,7 @@ inline void keywordMISC( SummaryConfig::keyword_list& list,
return;
auto param = SummaryNode {
keyword.name(), SummaryNode::Category::Segment
keyword.name(), SummaryNode::Category::Segment, keyword.location()
}
.namedEntity( well.name() )
.isUserDefined( is_udq(keyword.name()) );
@@ -767,6 +775,7 @@ inline void keywordMISC( SummaryConfig::keyword_list& list,
inline void handleKW( SummaryConfig::keyword_list& list,
const std::string& keyword,
Location loc,
const Schedule& schedule,
const ParseContext& parseContext,
ErrorGuard& errors) {
@@ -785,10 +794,10 @@ inline void handleKW( SummaryConfig::keyword_list& list,
const auto cat = parseKeywordCategory( keyword );
switch( cat ) {
case Cat::Well: return keywordW( list, keyword, schedule );
case Cat::Group: return keywordG( list, keyword, schedule );
case Cat::Field: return keywordF( list, keyword );
case Cat::Miscellaneous: return keywordMISC( list, keyword );
case Cat::Well: return keywordW( list, keyword, std::move(loc), schedule );
case Cat::Group: return keywordG( list, keyword, std::move(loc), schedule );
case Cat::Field: return keywordF( list, keyword, std::move(loc) );
case Cat::Miscellaneous: return keywordMISC( list, keyword, std::move(loc));
default:
throw std::logic_error("Keyword type: " + to_string( cat ) + " is not supported in alias lists. Internal error handling: " + keyword);
@@ -805,9 +814,10 @@ inline void handleKW( SummaryConfig::keyword_list& list,
// =====================================================================
SummaryNode::SummaryNode(std::string keyword, const Category cat) :
SummaryNode::SummaryNode(std::string keyword, const Category cat, Location loc_arg) :
keyword_(std::move(keyword)),
category_(cat)
category_(cat),
loc(std::move(loc_arg))
{}
SummaryNode& SummaryNode::parameterType(const Type type)
@@ -957,31 +967,13 @@ SummaryConfig::SummaryConfig( const Deck& deck,
handleKW( this->keywords, kw, schedule, tables, parseContext, errors, dims);
}
if( section.hasKeyword( "ALL" ) ) {
for (const auto& kw : ALL_keywords) {
if (!this->hasKeyword(kw))
handleKW(this->keywords, kw, schedule, parseContext, errors);
}
}
if( section.hasKeyword( "GMWSET" ) ) {
for (const auto& kw : GMWSET_keywords) {
if (!this->hasKeyword(kw))
handleKW(this->keywords, kw, schedule, parseContext, errors);
}
}
if( section.hasKeyword( "FMWSET" ) ) {
for (const auto& kw : FMWSET_keywords) {
if (!this->hasKeyword(kw))
handleKW(this->keywords, kw, schedule, parseContext, errors);
}
}
if( section.hasKeyword( "PERFORMA" ) ) {
for (const auto& kw : PERFORMA_keywords) {
if (!this->hasKeyword(kw))
handleKW(this->keywords, kw, schedule, parseContext, errors);
for (const auto& meta_pair : meta_keywords) {
if( section.hasKeyword( meta_pair.first ) ) {
const auto& deck_keyword = section.getKeyword(meta_pair.first);
for (const auto& kw : meta_pair.second) {
if (!this->hasKeyword(kw))
handleKW(this->keywords, kw, deck_keyword.location(), schedule, parseContext, errors);
}
}
}