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

Merge pull request #1013 from stefoss23/properties_py_decap

Browse Source 
Replace python class EclipseState
This commit is contained in:
Joakim Hove
2019-09-14 08:23:55 +02:00
committed by GitHub
parent 74291cc57f b957ca6a69
commit 1a23df1e2f
10 changed files with 226 additions and 279 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
python/cxx/eclipse_grid.cpp
View File

@@ -45,12 +45,15 @@ void python::common::export_EclipseGrid(py::module& module) {
py::class_< EclipseGrid >( module, "EclipseGrid")
.def( "_getXYZ", &getXYZ )
.def( "nactive", &getNumActive )
.def( "cartesianSize", &getCartesianSize )
.def_property_readonly("nx", &EclipseGrid::getNX)
.def_property_readonly("ny", &EclipseGrid::getNY)
.def_property_readonly("nz", &EclipseGrid::getNZ)
.def_property_readonly( "nactive", &getNumActive )
.def_property_readonly( "cartesianSize", &getCartesianSize )
.def( "globalIndex", &getGlobalIndex )
.def( "getIJK", &getIJK )
.def( "_cellVolume1G", &cellVolume1G)
.def( "_cellVolume3", &cellVolume3)
.def( "getCellVolume", &cellVolume1G)
.def( "getCellVolume", &cellVolume3)
;
}

11
python/cxx/eclipse_state.cpp
View File

@@ -1,3 +1,5 @@
#include <opm/parser/eclipse/Deck/Deck.hpp>
#include <opm/parser/eclipse/EclipseState/EclipseState.hpp>
#include <opm/parser/eclipse/EclipseState/Grid/FaultCollection.hpp>
@@ -88,11 +90,12 @@ namespace {
void python::common::export_EclipseState(py::module& module) {
py::class_< EclipseState >( module, "EclipseState" )
.def(py::init<const Deck&>())
.def_property_readonly( "title", &EclipseState::getTitle )
.def( "_props", &EclipseState::get3DProperties, ref_internal)
.def( "_grid", &EclipseState::getInputGrid, ref_internal)
.def( "_cfg", &EclipseState::cfg, ref_internal)
.def( "_tables", &EclipseState::getTableManager, ref_internal)
.def( "props", &EclipseState::get3DProperties, ref_internal)
.def( "grid", &EclipseState::getInputGrid, ref_internal)
.def( "config", &EclipseState::cfg, ref_internal)
.def( "tables", &EclipseState::getTableManager, ref_internal)
.def( "has_input_nnc", &EclipseState::hasInputNNC )
.def( "simulation", &EclipseState::getSimulationConfig, ref_internal)
.def( "input_nnc", &getNNC )

15
python/cxx/table_manager.cpp
View File

@@ -5,13 +5,12 @@
namespace {
double evaluate( const TableManager& tab,
std::string tab_name,
int tab_idx,
std::string col_name, double x ) try {
return tab[tab_name].getTable(tab_idx).evaluate(col_name, x);
} catch( std::invalid_argument& e ) {
throw py::key_error( e.what() );
double eval( const TableManager& tab, std::string tab_name, int tab_idx, std::string col_name, double x ) {
try {
return tab[tab_name].getTable(tab_idx).evaluate(col_name, x);
} catch( std::invalid_argument& e ) {
throw py::key_error( e.what() );
}
}
}
@@ -20,6 +19,6 @@ void python::common::export_TableManager(py::module& module) {
py::class_< TableManager >( module, "Tables")
.def( "__contains__", &TableManager::hasTables )
.def("_evaluate", &evaluate );
.def("evaluate", &eval);
}

2
python/python/opm/_common.py
View File

@@ -12,7 +12,7 @@ from __future__ import absolute_import
from .libopmcommon_python import action
from .libopmcommon_python import Parser, ParseContext, ParserKeyword
from .libopmcommon_python import EclipseConfig
from .libopmcommon_python import EclipseState
#from .schedule import Well, Connection, Schedule
#from .config import EclipseConfig

2
python/python/opm/io/ecl_state/__init__.py
View File

@@ -1 +1 @@
from opm._common import EclipseConfig
from opm._common import EclipseState

95
python/python/opm/io/parser/properties.py
View File

@@ -5,105 +5,10 @@ from opm import libopmcommon_python as lib
from .sunbeam import delegate
from ..schedule import Schedule
@delegate(lib.EclipseState)
class EclipseState(object):
def __repr__(self):
return 'EclipseState(title = "%s")' % self.title
def props(self):
return Eclipse3DProperties(self._props())
def grid(self):
return EclipseGrid(self._grid())
@property
def table(self):
return Tables(self._tables())
def faults(self):
"""Returns a map from fault names to list of (i,j,k,D) where D ~ 'X+'"""
fs = {}
for fn in self.faultNames():
fs[fn] = self.faultFaces(fn)
return fs
@delegate(lib.Eclipse3DProperties)
class Eclipse3DProperties(object):
def __repr__(self):
return 'Eclipse3DProperties()'
@delegate(lib.Tables)
class Tables(object):
def __repr__(self):
return 'Tables()'
def _eval(self, x, table, col_name, tab_idx = 0):
return self._evaluate(table, tab_idx, col_name, x)
def __getitem__(self, tab_name):
col_name = None
if isinstance(tab_name, tuple):
tab_name, col_name = tab_name
tab_name = tab_name.upper()
if not tab_name in self:
raise ValueError('Table "%s" not in deck.' % tab_name)
if col_name is None:
def t_eval(col_name, x, tab_idx = 0):
return self._eval(x, tab_name, col_name.upper(), tab_idx)
return t_eval
col_name = col_name.upper()
def t_eval(x, tab_idx = 0):
return self._eval(x, tab_name, col_name, tab_idx)
return t_eval
@delegate(lib.EclipseGrid)
class EclipseGrid(object):
def getNX(self):
return self._getXYZ()[0]
def getNY(self):
return self._getXYZ()[1]
def getNZ(self):
return self._getXYZ()[2]
def getCellVolume(self, global_idx=None, i_idx=None, j_idx=None, k_idx=None):
if global_idx is not None:
if set([i_idx, j_idx, k_idx]) != set([None]):
raise ValueError('Specify exactly one of global and all three i,j,k.')
return self._cellVolume1G(global_idx)
if None in [i_idx, j_idx, k_idx]:
raise ValueError('If not global_idx, need all three of i_idx, j_idx, and k_idx.')
return self._cellVolume3(i_idx, j_idx, k_idx)
def eclGrid(self):
return self._ecl_grid_ptr()
def __repr__(self):
x,y,z = self._getXYZ()
g = self.cartesianSize()
na = self.nactive()
cnt = '(%d, %d, %d)' % (x,y,z)
if na != g:
cnt += ', active = %s' % na
return 'EclipseGrid(%s)' % cnt
@delegate(lib.SunbeamState)
class SunbeamState(object):
@property
def state(self):
return EclipseState(self._state())
@property
def schedule(self):

6
python/tests/test_parse.py
View File

@@ -32,9 +32,11 @@ FIPNUM
self.spe3fn = 'tests/spe3/SPE3CASE1.DATA'
self.norne_fname = os.path.abspath('examples/data/norne/NORNE_ATW2013.DATA')
"""
def test_parse(self):
spe3 = opm.io.parse(self.spe3fn)
self.assertEqual('SPE 3 - CASE 1', spe3.state.title)
"""
def test_parse_with_recovery(self):
recovery = [("PARSE_RANDOM_SLASH", opm.io.action.ignore)]
@@ -63,11 +65,13 @@ FIPNUM
def test_parse_norne(self):
state = opm.io.parse(self.norne_fname, recovery=[('PARSE_RANDOM_SLASH', opm.io.action.ignore)])
"""
es = state.state
self.assertEqual(46, es.grid().getNX())
self.assertEqual(112, es.grid().getNY())
self.assertEqual(22, es.grid().getNZ())
"""
if __name__ == "__main__":
unittest.main()

34
python/tests/test_props.py
View File

@@ -1,6 +1,10 @@
import unittest
import opm.io
from opm.io.parser import Parser
from opm.io.ecl_state import EclipseState
class TestProps(unittest.TestCase):
def assertClose(self, expected, observed, epsilon=1e-08):
@@ -9,12 +13,11 @@ class TestProps(unittest.TestCase):
self.assertTrue(diff <= epsilon, msg=err_msg)
def setUp(self):
self.spe3 = opm.io.parse('tests/spe3/SPE3CASE1.DATA').state
parser = Parser()
deck = parser.parse('tests/spe3/SPE3CASE1.DATA')
self.spe3 = EclipseState(deck)
self.props = self.spe3.props()
def test_repr(self):
self.assertTrue('Eclipse3DProperties' in repr(self.props))
def test_contains(self):
p = self.props
self.assertTrue('PORO' in p)
@@ -33,35 +36,36 @@ class TestProps(unittest.TestCase):
def test_permx_values(self):
def md2si(md):
"""millidarcy->SI"""
#millidarcy->SI
return md * 1e-3 * 9.869233e-13
e3dp = self.props
grid = self.spe3.grid()
permx = e3dp['PERMX']
print('set(PERMX) = %s' % set(permx))
# 130mD, 40mD, 20mD, and 150mD, respectively, top to bottom
darcys = {0:md2si(130), 1:md2si(40), 2:md2si(20), 3:md2si(150)}
for i in range(grid.getNX()):
for j in range(grid.getNY()):
for k in range(grid.getNZ()):
for i in range(grid.nx):
for j in range(grid.ny):
for k in range(grid.nz):
g_idx = grid.globalIndex(i,j,k)
perm = permx[g_idx]
darcy = darcys[k]
self.assertClose(darcy, perm)
def test_volume(self):
e3dp = self.props
grid = self.spe3.grid()
for i in range(grid.getNX()):
for j in range(grid.getNY()):
for k in range(grid.getNZ()):
for i in range(grid.nx):
for j in range(grid.ny):
for k in range(grid.nz):
g_idx = grid.globalIndex(i,j,k)
exp = 293.3 * 293.3 * 30 # cubicfeet = 73 078.6084 cubic meter
exp *= (12*0.0254)**3 # cubic feet to cubic meter
if k == 0:
self.assertClose(exp, grid.getCellVolume(g_idx))
self.assertEqual(grid.getCellVolume(g_idx), grid.getCellVolume(None, i, j, k))
self.assertEqual(grid.getCellVolume(g_idx), grid.getCellVolume(i, j, k))
if __name__ == "__main__":
unittest.main()

153
python/tests/test_state.py
View File

@@ -2,167 +2,22 @@ import unittest
import opm.io
class TestState(unittest.TestCase):
FAULTS_DECK = """
RUNSPEC
DIMENS
10 10 10 /
GRID
DX
1000*0.25 /
DY
1000*0.25 /
DZ
1000*0.25 /
TOPS
100*0.25 /
FAULTS
'F1' 1 1 1 4 1 4 'X' /
'F2' 5 5 1 4 1 4 'X-' /
/
MULTFLT
'F1' 0.50 /
'F2' 0.50 /
/
EDIT
MULTFLT /
'F2' 0.25 /
/
OIL
GAS
TITLE
The title
START
8 MAR 1998 /
PROPS
REGIONS
SWAT
1000*1 /
SATNUM
1000*2 /
\
"""
@classmethod
def setUpClass(cls):
cls.spe3 = opm.io.parse('tests/spe3/SPE3CASE1.DATA')
cpa = opm.io.parse('tests/data/CORNERPOINT_ACTNUM.DATA')
cls.state = cls.spe3.state
cls.cp_state = cpa.state
def test_repr_title(self):
self.assertTrue('EclipseState' in repr(self.state))
self.assertEqual('SPE 3 - CASE 1', self.state.title)
def test_state_nnc(self):
self.assertFalse(self.state.has_input_nnc())
def test_grid(self):
grid = self.state.grid()
self.assertTrue('EclipseGrid' in repr(grid))
self.assertEqual(9, grid.getNX())
self.assertEqual(9, grid.getNY())
self.assertEqual(4, grid.getNZ())
self.assertEqual(9*9*4, grid.nactive())
self.assertEqual(9*9*4, grid.cartesianSize())
g,i,j,k = 295,7,5,3
self.assertEqual(g, grid.globalIndex(i,j,k))
self.assertEqual((i,j,k), grid.getIJK(g))
def test_summary(self):
smry = self.spe3.summary_config
self.assertTrue('SummaryConfig' in repr(smry))
self.assertTrue('WOPR' in smry) # hasKeyword
self.assertFalse('NONO' in smry) # hasKeyword
def test_simulation(self):
sim = self.state.simulation()
self.assertFalse(sim.hasThresholdPressure())
self.assertFalse(sim.useCPR())
self.assertTrue(sim.hasDISGAS())
self.assertTrue(sim.hasVAPOIL())
def test_tables(self):
tables = self.state.table
self.assertTrue('SGOF' in tables)
self.assertTrue('SWOF' in tables)
self.assertFalse('SOF' in tables)
ct = self.cp_state.table
self.assertFalse('SGOF' in ct)
self.assertTrue('SWOF' in ct)
tab = 'SWOF'
col = 'KRW'
self.assertAlmostEqual(0.1345, self.state.table[tab](col, 0.5))
self.assertAlmostEqual(0.39, self.state.table[tab](col, 0.72))
self.assertAlmostEqual(0.1345, self.state.table[tab, col](0.5))
self.assertAlmostEqual(0.39, self.state.table[tab, col](0.72))
with self.assertRaises(KeyError):
self.state.table[tab, 'NO'](1)
def test_faults(self):
self.assertEquals([], self.state.faultNames())
self.assertEquals({}, self.state.faults())
faultdeck = opm.io.parse_string(self.FAULTS_DECK).state
self.assertEqual(['F1', 'F2'], faultdeck.faultNames())
# 'F2' 5 5 1 4 1 4 'X-' / \n"
f2 = faultdeck.faultFaces('F2')
self.assertTrue((4,0,0,'X-') in f2)
self.assertFalse((3,0,0,'X-') in f2)
def test_jfunc(self):
# jf["FLAG"] = WATER; # set in deck
# jf["DIRECTION"] = XY; # default
# jf["ALPHA_FACTOR"] = 0.5 # default
# jf["BETA_FACTOR"] = 0.5 # default
# jf["OIL_WATER"] = 21.0 # set in deck
# jf["GAS_OIL"] = -1.0 # N/A
js = opm.io.parse('tests/data/JFUNC.DATA').state
self.assertEqual('JFUNC TEST', js.title)
jf = js.jfunc()
print(jf)
self.assertEqual(jf['FLAG'], 'WATER')
self.assertEqual(jf['DIRECTION'], 'XY')
self.assertFalse('GAS_OIL' in jf)
self.assertTrue('OIL_WATER' in jf)
self.assertEqual(jf['OIL_WATER'], 21.0)
self.assertEqual(jf["ALPHA_FACTOR"], 0.5) # default
self.assertEqual(jf["BETA_FACTOR"], 0.5) # default
jfunc_gas = """RUNSPEC
DIMENS
10 10 10 /
GRID
DX
1000*0.25 /
DY
1000*0.25 /
DZ
1000*0.25 /
TOPS
100*0.25 /
JFUNC
GAS * 13.0 0.6 0.7 Z /
PROPS\nREGIONS
"""
js_gas = opm.io.parse_string(jfunc_gas).state
jf = js_gas.jfunc()
self.assertEqual(jf['FLAG'], 'GAS')
self.assertEqual(jf['DIRECTION'], 'Z')
self.assertTrue('GAS_OIL' in jf)
self.assertFalse('OIL_WATER' in jf)
self.assertEqual(jf['GAS_OIL'], 13.0)
self.assertEqual(jf["ALPHA_FACTOR"], 0.6) # default
self.assertEqual(jf["BETA_FACTOR"], 0.7) # default
if __name__ == "__main__":
unittest.main()

176
python/tests/test_state2.py
View File

@@ -1 +1,175 @@
from opm.io.ecl_state import EclipseConfig
import unittest
from opm.io.parser import Parser
from opm.io.ecl_state import EclipseState
class TestState2(unittest.TestCase):
FAULTS_DECK = """
RUNSPEC
DIMENS
10 10 10 /
GRID
DX
1000*0.25 /
DY
1000*0.25 /
DZ
1000*0.25 /
TOPS
100*0.25 /
FAULTS
'F1' 1 1 1 4 1 4 'X' /
'F2' 5 5 1 4 1 4 'X-' /
/
MULTFLT
'F1' 0.50 /
'F2' 0.50 /
/
EDIT
MULTFLT /
'F2' 0.25 /
/
OIL
GAS
TITLE
The title
START
8 MAR 1998 /
PROPS
REGIONS
SWAT
1000*1 /
SATNUM
1000*2 /
\
"""
@classmethod
def setUpClass(cls):
parser = Parser()
cls.deck_spe3 = parser.parse('tests/spe3/SPE3CASE1.DATA')
cls.deck_cpa = parser.parse('tests/data/CORNERPOINT_ACTNUM.DATA')
cls.state = EclipseState(cls.deck_spe3)
cls.cp_state = EclipseState(cls.deck_cpa)
def test_config(self):
cfg = self.state.config()
init = cfg.init()
self.assertTrue(init.hasEquil())
self.assertFalse(init.restartRequested())
self.assertEqual(0, init.getRestartStep())
rst = cfg.restart()
self.assertFalse(rst.getWriteRestartFile(0))
self.assertEqual(7, rst.getFirstRestartStep())
def test_repr_title(self):
self.assertEqual('SPE 3 - CASE 1', self.state.title)
def test_state_nnc(self):
self.assertFalse(self.state.has_input_nnc())
def test_grid(self):
grid = self.state.grid()
self.assertEqual(9, grid.nx)
self.assertEqual(9, grid.ny)
self.assertEqual(4, grid.nz)
self.assertEqual(9*9*4, grid.nactive)
self.assertEqual(9*9*4, grid.cartesianSize)
g,i,j,k = 295,7,5,3
self.assertEqual(g, grid.globalIndex(i,j,k))
self.assertEqual((i,j,k), grid.getIJK(g))
def test_simulation(self):
sim = self.state.simulation()
self.assertFalse(sim.hasThresholdPressure())
self.assertFalse(sim.useCPR())
self.assertTrue(sim.hasDISGAS())
self.assertTrue(sim.hasVAPOIL())
def test_tables(self):
tables = self.state.tables()
self.assertTrue('SGOF' in tables)
self.assertTrue('SWOF' in tables)
self.assertFalse('SOF' in tables)
ct = self.cp_state.tables()
self.assertFalse('SGOF' in ct)
self.assertTrue('SWOF' in ct)
tab = 'SWOF'
col = 'KRW'
self.assertAlmostEqual(0.1345, self.state.tables().evaluate(tab, 0, col, 0.5))
self.assertAlmostEqual(0.39, self.state.tables().evaluate(tab, 0, col, 0.72))
with self.assertRaises(KeyError):
self.state.tables().evaluate(tab, 0, 'NO', 1)
def test_faults(self):
self.assertEquals([], self.state.faultNames())
parser = Parser()
faultdeck = parser.parse_string(self.FAULTS_DECK)
faultstate = EclipseState(faultdeck)
self.assertEqual(['F1', 'F2'], faultstate.faultNames())
# 'F2' 5 5 1 4 1 4 'X-' / \n"
f2 = faultstate.faultFaces('F2')
self.assertTrue((4,0,0,'X-') in f2)
self.assertFalse((3,0,0,'X-') in f2)
def test_jfunc(self):
# jf["FLAG"] = WATER; # set in deck
# jf["DIRECTION"] = XY; # default
# jf["ALPHA_FACTOR"] = 0.5 # default
# jf["BETA_FACTOR"] = 0.5 # default
# jf["OIL_WATER"] = 21.0 # set in deck
# jf["GAS_OIL"] = -1.0 # N/A
parser = Parser()
deck = parser.parse('tests/data/JFUNC.DATA')
js = EclipseState(deck)
self.assertEqual('JFUNC TEST', js.title)
jf = js.jfunc()
print(jf)
self.assertEqual(jf['FLAG'], 'WATER')
self.assertEqual(jf['DIRECTION'], 'XY')
self.assertFalse('GAS_OIL' in jf)
self.assertTrue('OIL_WATER' in jf)
self.assertEqual(jf['OIL_WATER'], 21.0)
self.assertEqual(jf["ALPHA_FACTOR"], 0.5) # default
self.assertEqual(jf["BETA_FACTOR"], 0.5) # default
jfunc_gas = """
DIMENS
10 10 10 /
GRID
DX
1000*0.25 /
DY
1000*0.25 /
DZ
1000*0.25 /
TOPS
100*0.25 /
JFUNC
GAS * 13.0 0.6 0.7 Z /
PROPS\nREGIONS
"""
deck2 = parser.parse_string(jfunc_gas)
js_gas = EclipseState(deck2)
jf = js_gas.jfunc()
self.assertEqual(jf['FLAG'], 'GAS')
self.assertEqual(jf['DIRECTION'], 'Z')
self.assertTrue('GAS_OIL' in jf)
self.assertFalse('OIL_WATER' in jf)
self.assertEqual(jf['GAS_OIL'], 13.0)
self.assertEqual(jf["ALPHA_FACTOR"], 0.6) # default
self.assertEqual(jf["BETA_FACTOR"], 0.7) # default