225 lines
8.1 KiB
C++
225 lines
8.1 KiB
C++
/*
|
|
Copyright 2016 Statoil ASA.
|
|
|
|
This file is part of the Open Porous Media project (OPM).
|
|
|
|
OPM is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
OPM is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with OPM. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
|
|
#include <opm/parser/eclipse/Deck/Deck.hpp>
|
|
#include <opm/parser/eclipse/Deck/DeckItem.hpp>
|
|
#include <opm/parser/eclipse/Deck/DeckKeyword.hpp>
|
|
#include <opm/parser/eclipse/Deck/DeckRecord.hpp>
|
|
#include <opm/parser/eclipse/Deck/Section.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Schedule/Completion.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Schedule/CompletionSet.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Schedule/Group.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Schedule/TimeMap.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Summary/Summary.hpp>
|
|
#include <opm/parser/eclipse/Utility/Functional.hpp>
|
|
|
|
#include <ert/ecl/ecl_smspec.h>
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
|
|
namespace Opm {
|
|
|
|
static std::string wellName( const std::shared_ptr< const Well >& well ) {
|
|
return well->name();
|
|
}
|
|
|
|
static std::string groupName( const Group* group ) {
|
|
return group->name();
|
|
}
|
|
|
|
static inline std::vector< ERT::smspec_node > keywordWG(
|
|
ecl_smspec_var_type var_type,
|
|
const DeckKeyword& keyword,
|
|
const EclipseState& es ) {
|
|
|
|
const auto mknode = [&keyword,var_type]( const std::string& name ) {
|
|
return ERT::smspec_node( var_type, name, keyword.name() );
|
|
};
|
|
|
|
const auto find = []( ecl_smspec_var_type v, const EclipseState& est ) {
|
|
if( v == ECL_SMSPEC_WELL_VAR )
|
|
return fun::map( wellName, est.getSchedule()->getWells() );
|
|
else
|
|
return fun::map( groupName, est.getSchedule()->getGroups() );
|
|
};
|
|
|
|
const auto& item = keyword.getDataRecord().getDataItem();
|
|
const auto wgnames = item.size() > 0 && item.hasValue( 0 )
|
|
? item.getData< std::string >()
|
|
: find( var_type, es );
|
|
|
|
return fun::map( mknode, wgnames );
|
|
}
|
|
|
|
static inline std::vector< ERT::smspec_node > keywordF(
|
|
const DeckKeyword& keyword,
|
|
const EclipseState& /* es */ ) {
|
|
|
|
std::vector< ERT::smspec_node > res;
|
|
res.push_back( ERT::smspec_node( keyword.name() ) );
|
|
return res;
|
|
}
|
|
|
|
static inline std::array< int, 3 > dimensions( const EclipseGrid& grid ) {
|
|
return {
|
|
int( grid.getNX() ),
|
|
int( grid.getNY() ),
|
|
int( grid.getNZ() )
|
|
};
|
|
}
|
|
|
|
static inline std::array< int, 3 > getijk( const DeckRecord& record,
|
|
int init = 0 )
|
|
{
|
|
return {
|
|
record.getItem( init + 0 ).get< int >( 0 ) - 1,
|
|
record.getItem( init + 1 ).get< int >( 0 ) - 1,
|
|
record.getItem( init + 2 ).get< int >( 0 ) - 1
|
|
};
|
|
}
|
|
|
|
static inline std::array< int, 3 > getijk( const Completion& completion ) {
|
|
return { completion.getI(), completion.getJ(), completion.getK() };
|
|
}
|
|
|
|
static inline std::vector< ERT::smspec_node > keywordB(
|
|
const DeckKeyword& keyword,
|
|
const EclipseState& es ) {
|
|
|
|
auto dims = dimensions( *es.getEclipseGrid() );
|
|
|
|
const auto mkrecord = [&dims,&keyword]( const DeckRecord& record ) {
|
|
auto ijk = getijk( record );
|
|
return ERT::smspec_node( keyword.name(), dims.data(), ijk.data() );
|
|
};
|
|
|
|
return fun::map( mkrecord, keyword );
|
|
}
|
|
|
|
static inline std::vector< ERT::smspec_node > keywordR(
|
|
const DeckKeyword& keyword,
|
|
const EclipseState& es ) {
|
|
|
|
auto dims = dimensions( *es.getEclipseGrid() );
|
|
|
|
const auto mknode = [&dims,&keyword]( int region ) {
|
|
return ERT::smspec_node( keyword.name(), dims.data(), region );
|
|
};
|
|
|
|
const auto& item = keyword.getDataRecord().getDataItem();
|
|
const auto regions = item.size() > 0 && item.hasValue( 0 )
|
|
? item.getData< int >()
|
|
: es.getRegions();
|
|
|
|
return fun::map( mknode, regions );
|
|
}
|
|
|
|
static inline std::vector< ERT::smspec_node > keywordC(
|
|
const DeckKeyword& keyword,
|
|
const EclipseState& es ) {
|
|
|
|
std::vector< ERT::smspec_node > nodes;
|
|
const auto& keywordstring = keyword.name();
|
|
const auto& schedule = es.getSchedule();
|
|
const auto last_timestep = schedule->getTimeMap()->last();
|
|
auto dims = dimensions( *es.getEclipseGrid() );
|
|
|
|
for( const auto& record : keyword ) {
|
|
|
|
if( record.getItem( 0 ).defaultApplied( 0 ) ) {
|
|
for( const auto& well : schedule->getWells() ) {
|
|
|
|
const auto& name = wellName( well );
|
|
|
|
for( const auto& completion : *well->getCompletions( last_timestep ) ) {
|
|
auto cijk = getijk( *completion );
|
|
|
|
/* well defaulted, block coordinates defaulted */
|
|
if( record.getItem( 1 ).defaultApplied( 0 ) ) {
|
|
nodes.emplace_back( keywordstring, name, dims.data(), cijk.data() );
|
|
}
|
|
/* well defaulted, block coordinates specified */
|
|
else {
|
|
auto recijk = getijk( record, 1 );
|
|
if( std::equal( recijk.begin(), recijk.end(), cijk.begin() ) )
|
|
nodes.emplace_back( keywordstring, name, dims.data(), cijk.data() );
|
|
}
|
|
}
|
|
}
|
|
|
|
} else {
|
|
const auto& name = record.getItem( 0 ).get< std::string >( 0 );
|
|
/* all specified */
|
|
if( !record.getItem( 1 ).defaultApplied( 0 ) ) {
|
|
auto ijk = getijk( record, 1 );
|
|
nodes.emplace_back( keywordstring, name, dims.data(), ijk.data() );
|
|
}
|
|
else {
|
|
/* well specified, block coordinates defaulted */
|
|
for( const auto& completion : *schedule->getWell( name ).getCompletions( last_timestep ) ) {
|
|
auto ijk = getijk( *completion );
|
|
nodes.emplace_back( keywordstring, name, dims.data(), ijk.data() );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return nodes;
|
|
}
|
|
|
|
std::vector< ERT::smspec_node > handleKW( const DeckKeyword& keyword, const EclipseState& es ) {
|
|
const auto var_type = ecl_smspec_identify_var_type( keyword.name().c_str() );
|
|
|
|
switch( var_type ) {
|
|
case ECL_SMSPEC_WELL_VAR: /* intentional fall-through */
|
|
case ECL_SMSPEC_GROUP_VAR: return keywordWG( var_type, keyword, es );
|
|
case ECL_SMSPEC_FIELD_VAR: return keywordF( keyword, es );
|
|
case ECL_SMSPEC_BLOCK_VAR: return keywordB( keyword, es );
|
|
case ECL_SMSPEC_REGION_VAR: return keywordR( keyword, es );
|
|
case ECL_SMSPEC_COMPLETION_VAR: return keywordC( keyword, es );
|
|
|
|
default: return {};
|
|
}
|
|
}
|
|
|
|
Summary::Summary( const Deck& deck, const EclipseState& es ) {
|
|
|
|
SUMMARYSection section( deck );
|
|
const auto handler = [&es]( const DeckKeyword& kw ) {
|
|
return handleKW( kw, es );
|
|
};
|
|
this->keywords = fun::concat( fun::map( handler, section ) );
|
|
}
|
|
|
|
Summary::const_iterator Summary::begin() const {
|
|
return this->keywords.cbegin();
|
|
}
|
|
|
|
Summary::const_iterator Summary::end() const {
|
|
return this->keywords.cend();
|
|
}
|
|
|
|
}
|