255 lines
7.8 KiB
C++
255 lines
7.8 KiB
C++
#include <boost/python.hpp>
|
|
#include <boost/python/suite/indexing/vector_indexing_suite.hpp>
|
|
|
|
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Grid/EclipseGrid.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Schedule/Schedule.hpp>
|
|
#include <opm/parser/eclipse/EclipseState/Schedule/Well.hpp>
|
|
#include <opm/parser/eclipse/Parser/Parser.hpp>
|
|
|
|
#include "converters.hpp"
|
|
|
|
namespace py = boost::python;
|
|
using namespace Opm;
|
|
|
|
namespace {
|
|
|
|
namespace state {
|
|
py::list getNNC( const EclipseState& state ) {
|
|
py::list l;
|
|
for( const auto& x : state.getInputNNC().nncdata() )
|
|
l.append( py::make_tuple( x.cell1, x.cell2, x.trans ) );
|
|
return l;
|
|
}
|
|
}
|
|
|
|
namespace grid {
|
|
py::tuple getXYZ( const EclipseGrid& grid ) {
|
|
return py::make_tuple( grid.getNX(),
|
|
grid.getNY(),
|
|
grid.getNZ());
|
|
}
|
|
int getNumActive( const EclipseGrid& grid ) {
|
|
return grid.getNumActive();
|
|
}
|
|
int getCartesianSize( const EclipseGrid& grid ) {
|
|
return grid.getCartesianSize();
|
|
}
|
|
int getGlobalIndex( const EclipseGrid& grid, int i, int j, int k ) {
|
|
return grid.getGlobalIndex(i, j, k);
|
|
}
|
|
py::tuple getIJK( const EclipseGrid& grid, int g ) {
|
|
const auto& ijk = grid.getIJK(g);
|
|
return py::make_tuple(ijk[0], ijk[1], ijk[2]);
|
|
}
|
|
}
|
|
|
|
namespace props {
|
|
py::list getitem( const Eclipse3DProperties& p, const std::string& kw) {
|
|
const auto& ip = p.getIntProperties();
|
|
if (ip.supportsKeyword(kw) && ip.hasKeyword(kw))
|
|
return iterable_to_pylist(p.getIntGridProperty(kw).getData());
|
|
|
|
const auto& dp = p.getDoubleProperties();
|
|
if (dp.supportsKeyword(kw) && dp.hasKeyword(kw))
|
|
return iterable_to_pylist(p.getDoubleGridProperty(kw).getData());
|
|
throw key_error( "no such grid property " + kw );
|
|
}
|
|
|
|
bool contains( const Eclipse3DProperties& p, const std::string& kw) {
|
|
return
|
|
(p.getIntProperties().supportsKeyword(kw) &&
|
|
p.getIntProperties().hasKeyword(kw))
|
|
||
|
|
(p.getDoubleProperties().supportsKeyword(kw) &&
|
|
p.getDoubleProperties().hasKeyword(kw))
|
|
;
|
|
}
|
|
py::list regions( const Eclipse3DProperties& p, const std::string& kw) {
|
|
return iterable_to_pylist( p.getRegions(kw) );
|
|
}
|
|
}
|
|
|
|
namespace group {
|
|
py::list wellnames( const Group& g, size_t timestep ) {
|
|
return iterable_to_pylist( g.getWells( timestep ) );
|
|
}
|
|
|
|
}
|
|
|
|
namespace well {
|
|
py::list completions( const Well& w) {
|
|
return iterable_to_pylist( w.getCompletions() );
|
|
}
|
|
|
|
std::string status( const Well& w, size_t timestep ) {
|
|
return WellCommon::Status2String( w.getStatus( timestep ) );
|
|
}
|
|
|
|
std::string preferred_phase( const Well& w ) {
|
|
switch( w.getPreferredPhase() ) {
|
|
case Phase::OIL: return "OIL";
|
|
case Phase::GAS: return "GAS";
|
|
case Phase::WATER: return "WATER";
|
|
default: throw std::logic_error( "Unhandled enum value" );
|
|
}
|
|
}
|
|
|
|
int (Well::*headI)() const = &Well::getHeadI;
|
|
int (Well::*headJ)() const = &Well::getHeadI;
|
|
double (Well::*refD)() const = &Well::getRefDepth;
|
|
|
|
int (Well::*headI_at)(size_t) const = &Well::getHeadI;
|
|
int (Well::*headJ_at)(size_t) const = &Well::getHeadI;
|
|
double (Well::*refD_at)(size_t) const = &Well::getRefDepth;
|
|
|
|
}
|
|
|
|
namespace schedule {
|
|
|
|
std::vector< Well > get_wells( const Schedule& sch ) {
|
|
std::vector< Well > wells;
|
|
for( const auto& w : sch.getWells() )
|
|
wells.push_back( *w );
|
|
|
|
return wells;
|
|
}
|
|
|
|
const Well& get_well( const Schedule& sch, const std::string& name ) try {
|
|
return *sch.getWell( name );
|
|
} catch( const std::invalid_argument& e ) {
|
|
throw key_error( name );
|
|
}
|
|
|
|
|
|
boost::posix_time::ptime get_start_time( const Schedule& s ) {
|
|
return boost::posix_time::from_time_t( s.posixStartTime() );
|
|
}
|
|
|
|
boost::posix_time::ptime get_end_time( const Schedule& s ) {
|
|
return boost::posix_time::from_time_t( s.posixEndTime() );
|
|
}
|
|
|
|
py::list get_timesteps( const Schedule& s ) {
|
|
const auto& tm = s.getTimeMap();
|
|
std::vector< boost::posix_time::ptime > v;
|
|
v.reserve( tm.size() );
|
|
|
|
for( size_t i = 0; i < tm.size(); ++i ) v.push_back( tm[ i ] );
|
|
|
|
return iterable_to_pylist( v );
|
|
}
|
|
|
|
py::list get_groups( const Schedule& sch ) {
|
|
std::vector< Group > groups;
|
|
for( const auto& g : sch.getGroups() )
|
|
groups.push_back( *g );
|
|
|
|
return iterable_to_pylist( groups );
|
|
}
|
|
|
|
}
|
|
|
|
EclipseState (*parse)( const std::string&, const ParseContext& ) = &Parser::parse;
|
|
EclipseState (*parseData) (const std::string &data, const ParseContext& context) = &Parser::parseData;
|
|
void (ParseContext::*ctx_update)(const std::string&, InputError::Action) = &ParseContext::update;
|
|
|
|
}
|
|
|
|
BOOST_PYTHON_MODULE(libsunbeam) {
|
|
/*
|
|
* Python C-API requires this macro to be invoked before anything from
|
|
* datetime.h is used.
|
|
*/
|
|
PyDateTime_IMPORT;
|
|
|
|
/* register all converters */
|
|
py::to_python_converter< const boost::posix_time::ptime,
|
|
ptime_to_python_datetime >();
|
|
|
|
py::register_exception_translator< key_error >( &key_error::translate );
|
|
|
|
py::def( "parse", parse );
|
|
py::def( "parseData", parseData );
|
|
|
|
py::class_< EclipseState >( "EclipseState", py::no_init )
|
|
.add_property( "title", &EclipseState::getTitle )
|
|
.def( "_schedule", &EclipseState::getSchedule, ref() )
|
|
.def( "_props", &EclipseState::get3DProperties, ref() )
|
|
.def( "_grid", &EclipseState::getInputGrid, ref() )
|
|
.def( "has_input_nnc", &EclipseState::hasInputNNC )
|
|
.def( "input_nnc", state::getNNC )
|
|
;
|
|
|
|
py::class_< EclipseGrid >( "EclipseGrid", py::no_init )
|
|
.def( "_getXYZ", grid::getXYZ )
|
|
.def( "nactive", grid::getNumActive )
|
|
.def( "cartesianSize", grid::getCartesianSize )
|
|
.def( "globalIndex", grid::getGlobalIndex )
|
|
.def( "getIJK", grid::getIJK )
|
|
;
|
|
|
|
py::class_< Eclipse3DProperties >( "Eclipse3DProperties", py::no_init )
|
|
.def( "getRegions", props::regions )
|
|
.def( "__contains__", props::contains )
|
|
.def( "__getitem__", props::getitem )
|
|
;
|
|
|
|
py::class_< Well >( "Well", py::no_init )
|
|
.add_property( "name", mkcopy( &Well::name ) )
|
|
.add_property( "preferred_phase", &well::preferred_phase )
|
|
.def( "I", well::headI )
|
|
.def( "I", well::headI_at )
|
|
.def( "J", well::headJ )
|
|
.def( "J", well::headJ_at )
|
|
.def( "ref", well::refD )
|
|
.def( "ref", well::refD_at )
|
|
.def( "status", &well::status )
|
|
.def( "isdefined", &Well::hasBeenDefined )
|
|
.def( "isinjector", &Well::isInjector )
|
|
.def( "isproducer", &Well::isProducer )
|
|
.def( "group", &Well::getGroupName )
|
|
.def( "guide_rate", &Well::getGuideRate )
|
|
.def( "available_gctrl", &Well::isAvailableForGroupControl )
|
|
.def( "__eq__", &Well::operator== )
|
|
.def( "completions", well::completions )
|
|
;
|
|
|
|
py::class_< Completion >( "Completion", py::no_init )
|
|
.def( "getI", &Completion::getI )
|
|
.def( "getJ", &Completion::getJ )
|
|
.def( "getK", &Completion::getK )
|
|
;
|
|
|
|
|
|
py::class_< std::vector< Well > >( "WellList", py::no_init )
|
|
.def( py::vector_indexing_suite< std::vector< Well > >() )
|
|
;
|
|
|
|
py::class_< Group >( "Group", py::no_init )
|
|
.add_property( "name", mkcopy( &Group::name ) )
|
|
.def( "_wellnames", group::wellnames )
|
|
;
|
|
|
|
py::class_< Schedule >( "Schedule", py::no_init )
|
|
.add_property( "_wells", schedule::get_wells )
|
|
.add_property( "_groups", schedule::get_groups )
|
|
.add_property( "start", schedule::get_start_time )
|
|
.add_property( "end", schedule::get_end_time )
|
|
.add_property( "timesteps", schedule::get_timesteps )
|
|
.def( "__contains__", &Schedule::hasWell )
|
|
.def( "__getitem__", schedule::get_well, ref() )
|
|
.def( "_group", &Schedule::getGroup, ref() )
|
|
;
|
|
|
|
py::class_< ParseContext >( "ParseContext" )
|
|
.def( "update", ctx_update )
|
|
;
|
|
|
|
py::enum_< InputError::Action >( "action" )
|
|
.value( "throw", InputError::Action::THROW_EXCEPTION )
|
|
.value( "warn", InputError::Action::WARN )
|
|
.value( "ignore", InputError::Action::IGNORE )
|
|
;
|
|
}
|