def test_polygon(self):
reg = EclRegion(self.grid, False)
(x,y,z) = self.grid.get_xyz( ijk=(10,10,0) )
dx = 0.1
dy = 0.1
reg.select_inside_polygon( [(x-dx,y-dy) , (x-dx,y+dy) , (x+dx,y+dy) , (x+dx,y-dy)] )
self.assertTrue( self.grid.getNZ() == len(reg.getGlobalList()))
def set_inner_region(self):
"""
Initializes inner region used to define the FLUXNUM
"""
self.inner_region = EclRegion(self.grid, False)
self.inner_region.select_all()
def test_polygon(self):
reg = EclRegion(self.grid, False)
(x,y,z) = self.grid.get_xyz( ijk=(10,10,0) )
dx = 0.1
dy = 0.1
reg.select_inside_polygon( [(x-dx,y-dy) , (x-dx,y+dy) , (x+dx,y+dy) , (x+dx,y-dy)] )
self.assertTrue( self.grid.getNZ() == len(reg.getGlobalList()))
def test_sum(self):
grid = EclGrid.createRectangular((10, 10, 1), (1, 1, 1))
kw_mask = EclKW("INT", grid.getGlobalSize(), EclDataType.ECL_INT)
int_value = EclKW("INT", grid.getGlobalSize(), EclDataType.ECL_INT)
float_value = EclKW("FLOAT", grid.getGlobalSize(),
EclDataType.ECL_FLOAT)
double_value = EclKW("DOUBLE", grid.getGlobalSize(),
EclDataType.ECL_DOUBLE)
bool_value = EclKW("BOOL", grid.getGlobalSize(), EclDataType.ECL_BOOL)
kw_mask[0:50] = 1
for i in range(len(int_value)):
float_value[i] = i
double_value[i] = i
int_value[i] = i
bool_value[i] = True
region = EclRegion(grid, False)
region.select_equal(kw_mask, 1)
self.assertEqual(int_value.sum(), 99 * 100 / 2)
self.assertEqual(int_value.sum(mask=region), 49 * 50 / 2)
self.assertEqual(double_value.sum(mask=region), 1.0 * 49 * 50 / 2)
self.assertEqual(float_value.sum(mask=region), 1.0 * 49 * 50 / 2)
self.assertEqual(bool_value.sum(mask=region), 50)
def test_kw_isub(self):
P = self.rst_file["PRESSURE"][5]
fipnum = self.init_file["FIPNUM"][0]
fipnum_copy = fipnum.deep_copy()
reg = EclRegion(self.grid, False)
reg.select_more(P, 260)
fipnum.sub(1, mask=reg)
self.assertFalse(fipnum.equal(fipnum_copy))
fipnum.add(1, mask=reg)
self.assertTrue(fipnum.equal(fipnum_copy))
def test_kw_isub(self):
P = self.rst_file["PRESSURE"][5]
fipnum = self.init_file["FIPNUM"][0]
fipnum_copy = fipnum.deep_copy()
reg = EclRegion(self.grid, False)
reg.select_more(P, 260)
fipnum.sub(1, mask=reg)
self.assertFalse(fipnum.equal(fipnum_copy))
fipnum.add(1, mask=reg)
self.assertTrue(fipnum.equal(fipnum_copy))
def setUp(self):
self.grid = EclGrid.createRectangular( (10,10,10) , (1,1,1) )
self.kw = EclKW( "FAULTBLK" , self.grid.getGlobalSize() , EclDataType.ECL_INT )
self.kw.assign( 1 )
reg = EclRegion( self.grid , False )
for k in range(self.grid.getNZ()):
reg.clear( )
reg.select_kslice( k , k )
self.kw.assign( k , mask = reg )
self.kw[ k * self.grid.getNX() * self.grid.getNY() + 7] = 177
def test_local_field(self):
with ErtTestContext('python/enkf/data/local_config', self.field_config) as test_context:
main = test_context.getErt()
local_config = main.getLocalConfig()
# Creating dataset
data_scale = local_config.createDataset('DATA_SCALE')
grid = local_config.getGrid()
ecl_reg = EclRegion(grid, False)
ecl_reg.select_islice(10, 20)
data_scale.addField('PERMX', ecl_reg)
self.assertEqual(1, len(data_scale))
def test_equal(self):
reg1 = EclRegion(self.grid, False)
reg2 = EclRegion(self.grid, False)
self.assertTrue(reg1 == reg2)
reg1.select_islice(4, 6)
self.assertFalse(reg1 == reg2)
reg2.select_islice(4, 7)
self.assertFalse(reg1 == reg2)
reg1.select_islice(7, 7)
self.assertTrue(reg1 == reg2)
def test_heidrun(self):
root = self.createTestPath("Statoil/ECLIPSE/Heidrun")
grid = EclGrid("%s/FF12_2013B2_AMAP_AOP-J15_NO62_MOVEX.EGRID" % root)
polygon = []
with open("%s/polygon.ply" % root) as fileH:
for line in fileH.readlines():
tmp = line.split()
polygon.append((float(tmp[0]), float(tmp[1])))
self.assertEqual(len(polygon), 11)
reg = EclRegion(grid, False)
reg.select_inside_polygon(polygon)
self.assertEqual(0, len(reg.getGlobalList()) % grid.getNZ())
def test_heidrun(self):
root = self.createTestPath("Statoil/ECLIPSE/Heidrun")
grid = EclGrid( "%s/FF12_2013B2_AMAP_AOP-J15_NO62_MOVEX.EGRID" % root)
polygon = []
with open("%s/polygon.ply" % root) as fileH:
for line in fileH.readlines():
tmp = line.split()
polygon.append( (float(tmp[0]) , float(tmp[1])))
self.assertEqual( len(polygon) , 11 )
reg = EclRegion( grid , False )
reg.select_inside_polygon( polygon )
self.assertEqual( 0 , len(reg.getGlobalList()) % grid.getNZ())
def test_local_field(self):
with ErtTestContext("python/enkf/data/local_config",
self.field_config) as test_context:
main = test_context.getErt()
local_config = main.getLocalConfig()
# Creating dataset
data_scale = local_config.createDataset("DATA_SCALE")
grid = local_config.getGrid()
ecl_reg = EclRegion(grid, False)
ecl_reg.select_islice(10, 20)
data_scale.addField("PERMX", ecl_reg)
self.assertEqual(1, len(data_scale))
# A totally invalid key -> KeyError exception
with self.assertRaises(KeyError):
data_scale.row_scaling("NO_SUCH_KEY")
row_scaling = data_scale.row_scaling("PERMX")
def test_equal(self):
reg1 = EclRegion(self.grid , False)
reg2 = EclRegion(self.grid , False)
self.assertTrue( reg1 == reg2 )
reg1.select_islice(4 , 6)
self.assertFalse( reg1 == reg2 )
reg2.select_islice(4,7)
self.assertFalse( reg1 == reg2 )
reg1.select_islice(7,7)
self.assertTrue( reg1 == reg2 )
def set_lgr_box_region(self, i, j, k):
"""
Sets an LGR region with one cell indent from the box boundaries.
Only works for Box regions
"""
self.lgr_region = EclRegion(self.grid, False)
ijk_list = flux_util.unpack_ijk(i, j, k)
# Drags lgr boundaries one cell from box region
i_lgr_start = ijk_list[0]
i_lgr_end = ijk_list[1] - 2
j_lgr_start = ijk_list[2]
j_lgr_end = ijk_list[3] - 2
k_lgr_start = ijk_list[4]
k_lgr_end = ijk_list[5] - 2
self.lgr_region.select_box((i_lgr_start, j_lgr_start, k_lgr_start),
(i_lgr_end, j_lgr_end, k_lgr_end))
def test_sum(self):
grid = EclGrid.createRectangular( (10,10,1) , (1,1,1))
kw_mask = EclKW( "INT" , grid.getGlobalSize( ) , EclDataType.ECL_INT )
int_value = EclKW( "INT" , grid.getGlobalSize( ) , EclDataType.ECL_INT )
float_value = EclKW( "FLOAT" , grid.getGlobalSize( ) , EclDataType.ECL_FLOAT)
double_value = EclKW( "DOUBLE" , grid.getGlobalSize( ) , EclDataType.ECL_DOUBLE )
bool_value = EclKW( "BOOL" , grid.getGlobalSize( ) , EclDataType.ECL_BOOL )
kw_mask[0:50] = 1
for i in range(len(int_value)):
float_value[i] = i
double_value[i] = i
int_value[i] = i
bool_value[i] = True
region = EclRegion(grid, False)
region.select_equal( kw_mask , 1 )
self.assertEqual( int_value.sum( ) , 99*100/2 )
self.assertEqual( int_value.sum( mask = region ) , 49*50/2 )
self.assertEqual( double_value.sum( mask = region ) , 1.0*49*50/2 )
self.assertEqual( float_value.sum( mask = region ) , 1.0*49*50/2 )
self.assertEqual( bool_value.sum( mask = region ) , 50 )
def test_equal(self):
grid = EclGrid.createRectangular((10, 10, 1), (1, 1, 1))
kw_int = EclKW("INT", grid.getGlobalSize(), EclDataType.ECL_INT)
kw_float = EclKW("FLOAT", grid.getGlobalSize(), EclDataType.ECL_FLOAT)
kw_int[0:49] = 1
region = EclRegion(grid, False)
region.select_equal(kw_int, 1)
glist = region.getGlobalList()
for g in glist:
self.assertEqual(kw_int[g], 1)
with self.assertRaises(ValueError):
region.select_equal(kw_float, 1)
def setUp(self):
self.grid = EclGrid.createRectangular( (10,10,10) , (1,1,1) )
self.kw = EclKW( "FAULTBLK" , self.grid.getGlobalSize() , EclDataType.ECL_INT )
self.kw.assign( 1 )
reg = EclRegion( self.grid , False )
for k in range(self.grid.getNZ()):
reg.clear( )
reg.select_kslice( k , k )
self.kw.assign( k , mask = reg )
self.kw[ k * self.grid.getNX() * self.grid.getNY() + 7] = 177
def test_equal(self):
grid = EclGrid.createRectangular( (10,10,1) , (1,1,1))
kw_int = EclKW( "INT" , grid.getGlobalSize( ) , EclDataType.ECL_INT )
kw_float = EclKW( "FLOAT" , grid.getGlobalSize( ) , EclDataType.ECL_FLOAT )
kw_int[0:49] = 1
region = EclRegion(grid, False)
region.select_equal( kw_int , 1 )
glist = region.getGlobalList()
for g in glist:
self.assertEqual( kw_int[g] , 1 )
with self.assertRaises(ValueError):
region.select_equal( kw_float , 1 )
def main(grid):
vmin,vmax = volume_min_max(grid)
dz_limit = 0.3
region = EclRegion(grid, False)
region.select_thin(dz_limit)
print "Smallest cell : %g" % vmin
print "Largest cell : %g" % vmax
print "Thin active cells : %d" % region.active_size()
for ai in region.get_active_list():
c = grid.cell(active_index=ai)
print('dz(%2d, %2d, %2d) = %.3f' % (c.i, c.j, c.k, c.dz))
class FluxnumBox(Fluxnum):
def __init__(self,
grid,
i_start,
i_end,
j_start,
j_end,
k_start=0,
k_end=0):
"""
Define FLUXNUM region based on box dimensions
"""
Fluxnum.__init__(self, grid)
i_start -= 1
i_end -= 1
j_start -= 1
j_end -= 1
if k_end == 0:
k_start = 0
k_end = self.grid.nz - 1
else:
k_start -= 1
k_end -= 1
self.set_inner_region(i_start, i_end, j_start, j_end, k_start, k_end)
self.set_outer_region(i_start, i_end, j_start, j_end, k_start, k_end)
def set_inner_region(self, i_start, i_end, j_start, j_end, k_start, k_end):
self.inner_region = EclRegion(self.grid, False)
self.inner_region.select_box((i_start, j_start, k_start),
(i_end, j_end, k_end))
def set_outer_region(self, i_start, i_end, j_start, j_end, k_start, k_end):
self.outer_region = EclRegion(self.grid, False)
self.outer_region.select_box((i_start, j_start, k_start),
(i_end, j_end, k_end))
self.outer_region.invert()
def test_slice(self):
reg = EclRegion(self.grid, False)
reg.select_islice(0, 5)
OK = True
global_list = reg.getGlobalList()
self.assertEqual(global_list.parent(), reg)
for gi in global_list:
(i, j, k) = self.grid.get_ijk(global_index=gi)
if i > 5:
OK = False
self.assertTrue(OK)
self.assertTrue(self.grid.getNY() * self.grid.getNZ() * 6 == len(reg.getGlobalList()))
reg.select_jslice(7, 8, intersect=True)
OK = True
for gi in reg.getGlobalList():
(i, j, k) = self.grid.get_ijk(global_index=gi)
if i > 5:
OK = False
if j < 7 or j > 8:
OK = False
self.assertTrue(OK)
self.assertTrue(2 * self.grid.getNZ() * 6 == len(reg.getGlobalList()))
reg2 = EclRegion(self.grid, False)
reg2.select_kslice(3, 5)
reg &= reg2
OK = True
for gi in reg.getGlobalList():
(i, j, k) = self.grid.get_ijk(global_index=gi)
if i > 5:
OK = False
if j < 7 or j > 8:
OK = False
if k < 3 or k > 5:
OK = False
self.assertTrue(OK)
self.assertTrue(2 * 3 * 6 == len(reg.getGlobalList()))
def test_truth_and_size(self):
actnum = IntVector( initial_size = 100, default_value = 0)
actnum[0:50] = 1
grid = EclGrid.createRectangular( (10,10,1) , (1,1,1), actnum = actnum)
region = EclRegion(grid, False)
self.assertFalse( region )
self.assertEqual( 0, region.active_size( ))
self.assertEqual( 0, region.global_size( ))
region.select_all( )
self.assertTrue( region )
self.assertEqual( 50, region.active_size( ))
self.assertEqual( 100, region.global_size( ))
region.deselect_all()
self.assertFalse( region )
self.assertEqual( 0, region.active_size( ))
self.assertEqual( 0, region.global_size( ))
region = EclRegion(grid, False)
region.select_inactive()
self.assertTrue( region )
self.assertEqual( 0 , region.active_size( ))
self.assertEqual( 50, region.global_size( ))
init_file = EclFile("%s.INIT" % case)
# Create PORV keyword where all the inactive cells have been removed.
pv = grid.compressed_kw_copy(init_file["PORV"][0])
# Extract an integer region keyword from the init file
region_kw = init_file["EQLNUM"][0]
sim_days = []
result = {}
for header in rst_file.headers():
line = {}
rst_block = rst_file.restart_view(report_step=header.get_report_step())
p = rst_block["PRESSURE"][0]
sw = rst_block["SWAT"][0]
for region_id in range(region_kw.get_max() + 1):
region = EclRegion(grid, False)
region.select_equal(region_kw, region_id)
avg_pressure(p, sw, pv, region, region_id, result)
avg_pressure(p, sw, pv, EclRegion(grid, True), "field", result)
sim_days.append(header.get_sim_days())
for key in result.keys():
plt.figure(1)
for index, p in enumerate(result[key]):
plt.plot(sim_days, p, label="Region:%s P%d" % (key, index + 1))
plt.legend()
plt.show()
def test_grid_cell_bounding_boxes() -> None:
layers = ()
flowdata = FlowData(_locate_test_case(), layers)
# Test one layer for the whole field and no layers equal
flowdata._layers = ((1, flowdata.grid.nz),)
field_one_layer = flowdata.grid_cell_bounding_boxes(0)
flowdata._layers = ()
field_no_layer = flowdata.grid_cell_bounding_boxes(0)
assert_almost_equal(field_one_layer, field_no_layer)
# Test zero'th layer id
flowdata._layers = ((1, 2), (3, 4))
result = flowdata.grid_cell_bounding_boxes(0)
active_cells = EclRegion(flowdata.grid, True)
active_cells.select_kslice(
*tuple(map(operator.sub, flowdata._layers[0], (1, 1))), intersect=True
)
active_cells.select_active(intersect=True)
assert result.shape[0] == active_cells.active_size()
assert result.shape[1] == 6
# Test last layer id
flowdata._layers = ((1, 2), (3, 4))
result = flowdata.grid_cell_bounding_boxes(1)
active_cells = EclRegion(flowdata.grid, True)
active_cells.select_kslice(
*tuple(map(operator.sub, flowdata._layers[-1], (1, 1))), intersect=True
)
active_cells.select_active(intersect=True)
assert result.shape[0] == active_cells.active_size()
assert result.shape[1] == 6
def test_layer(self):
region = EclRegion(self.grid, False)
layer = Layer( self.grid.getNX() , self.grid.getNY() + 1)
with self.assertRaises(ValueError):
region.selectFromLayer( layer , 0 , 1 )
layer = Layer( self.grid.getNX() , self.grid.getNY() )
layer[0,0] = 1
layer[1,1] = 1
layer[2,2] = 1
with self.assertRaises(ValueError):
region.selectFromLayer( layer , -1 , 1 )
with self.assertRaises(ValueError):
region.selectFromLayer( layer , self.grid.getNZ() , 1 )
region.selectFromLayer( layer , 0 , 2 )
glist = region.getGlobalList()
self.assertEqual(0 , len(glist))
region.selectFromLayer( layer , 0 , 1 )
glist = region.getGlobalList()
self.assertEqual(3 , len(glist))
def test_EclRegion_properties(self):
grid = EclGridGenerator.createRectangular((10, 10, 10), (1, 1, 1))
region = EclRegion(grid, False)
def test_grid_cell_bounding_boxes() -> None:
layers = ()
flowdata = FlowData(
_locate_test_case(),
layers,
"multiple_based_on_workovers",
)
# Test no argument and entire field being equal
flowdata._layers = ((1, flowdata.grid.nz), )
assert_almost_equal(flowdata._grid_cell_bounding_boxes(),
flowdata._grid_cell_bounding_boxes(0))
# Test zero'th layer id
flowdata._layers = ((1, 2), (3, 4))
result = flowdata._grid_cell_bounding_boxes(0)
active_cells = EclRegion(flowdata.grid, True)
active_cells.select_kslice(*tuple(
map(operator.sub, flowdata._layers[0], (1, 1))),
intersect=True)
active_cells.select_active(intersect=True)
assert result.shape[0] == active_cells.active_size()
assert result.shape[1] == 6
# Test last layer id
flowdata._layers = ((1, 2), (3, 4))
result = flowdata._grid_cell_bounding_boxes(1)
active_cells = EclRegion(flowdata.grid, True)
active_cells.select_kslice(*tuple(
map(operator.sub, flowdata._layers[-1], (1, 1))),
intersect=True)
active_cells.select_active(intersect=True)
assert result.shape[0] == active_cells.active_size()
assert result.shape[1] == 6
def test_index_list(self):
reg = EclRegion(self.grid, False)
reg.select_islice(0, 5)
active_list = reg.getActiveList()
global_list = reg.getGlobalList()
def test_truth_and_size(self):
actnum = IntVector(initial_size=100, default_value=0)
actnum[0:50] = 1
grid = EclGrid.createRectangular((10, 10, 1), (1, 1, 1), actnum=actnum)
region = EclRegion(grid, False)
self.assertFalse(region)
self.assertEqual(0, region.active_size())
self.assertEqual(0, region.global_size())
region.select_all()
self.assertTrue(region)
self.assertEqual(50, region.active_size())
self.assertEqual(100, region.global_size())
region.deselect_all()
self.assertFalse(region)
self.assertEqual(0, region.active_size())
self.assertEqual(0, region.global_size())
region = EclRegion(grid, False)
region.select_inactive()
self.assertTrue(region)
self.assertEqual(0, region.active_size())
self.assertEqual(50, region.global_size())
def filter_region(grid,
i,
j,
k,
fipnum,
fipnum_kw,
combine_operator="intersect"):
# Filter out the selected grid cells
region = EclRegion(grid, False)
region1 = EclRegion(grid, False)
region_i = EclRegion(grid, False)
region_j = EclRegion(grid, False)
region_k = EclRegion(grid, False)
region_fip = EclRegion(grid, False)
# Create selected regions for each filter type
if i:
for i_slice in unpack_filter(i):
region_i.select_islice(i_slice - 1, i_slice -
1) # -1 because ert defines i=1 as i=0
else:
region_i.select_all()
if j:
for j_slice in unpack_filter(j):
region_j.select_jslice(j_slice - 1, j_slice -
1) # -1 because ert defines j=1 as j=0
else:
region_j.select_all()
if k:
for k_slice in unpack_filter(k):
region_k.select_kslice(k_slice - 1, k_slice -
1) # -1 because ert defines j=1 as j=0
else:
region_k.select_all()
if fipnum:
for fip in unpack_filter(fipnum):
print(fip)
region_fip.select_equal(fipnum_kw, fip)
else:
region_fip.select_all()
# Combine regions by
if (combine_operator == "intersect" or combine_operator == ""
or combine_operator is None):
# Intersection
region.select_all() # region.select_active()
region = region & region_i & region_j & region_k & region_fip
return region
elif combine_operator == "union":
# Union
region1.select_active()
region2 = region_i | region_j | region_k | region_fip
region = region1 & region2
return region
else:
raise Exception(
"ERROR: '%s' is not a valid operator to combine regions." %
combine_operator)
def filter_region_fipnum(grid,
fipnum,
fipnum_kw,
combine_operator="intersect"):
# Filter out the selected grid cells
region = EclRegion(grid, False)
region1 = EclRegion(grid, False)
region_fip = EclRegion(grid, False)
# Create selected regions for each filter type
if fipnum:
for fip in unpack_filter(fipnum):
region_fip.select_equal(fipnum_kw, fip)
else:
region_fip.select_all()
# Combine regions by
if (combine_operator == "intersect" or combine_operator == ""
or combine_operator is None):
# Intersection
region.select_all()
region = region & region_fip
return region
elif combine_operator == "union":
# Union
region1.select_active()
region2 = region_fip
region = region1 & region2
return region
else:
raise Exception(
"ERROR: '%s' is not a valid operator to combine regions." %
combine_operator)
def set_outer_region(self, i_start, i_end, j_start, j_end, k_start, k_end):
self.outer_region = EclRegion(self.grid, False)
self.outer_region.select_box((i_start, j_start, k_start),
(i_end, j_end, k_end))
self.outer_region.invert()
class Fluxnum:
"""Superclass"""
def __init__(self, grid):
# ParamObject.__init__(self)
"""
Input for all classes is the actual grid
Needed for evaluation of regions
Creates a non-initialized FLUXNUM keyword
"""
int_type = EclDataType.ECL_INT
self.grid = grid
self.fluxnum_kw = EclKW("FLUXNUM", grid.getGlobalSize(), int_type)
self.included_wells = []
self.dummy_lgr_cell = []
self.dummy_lgr_well = []
self.dummy_lgr_name = []
self.lgr_region = None
self.inner_region = None
def copy_actnum(self, actnum):
"""
Copy data from ACTNUM keyword to the FLUXNUM keyword
"""
self.fluxnum_kw = actnum.deep_copy()
self.fluxnum_kw.name = "FLUXNUM"
def set_inner_region(self):
"""
Initializes inner region used to define the FLUXNUM
"""
self.inner_region = EclRegion(self.grid, False)
self.inner_region.select_all()
def set_lgr_box_region(self, i, j, k):
"""
Sets an LGR region with one cell indent from the box boundaries.
Only works for Box regions
"""
self.lgr_region = EclRegion(self.grid, False)
ijk_list = flux_util.unpack_ijk(i, j, k)
# Drags lgr boundaries one cell from box region
i_lgr_start = ijk_list[0]
i_lgr_end = ijk_list[1] - 2
j_lgr_start = ijk_list[2]
j_lgr_end = ijk_list[3] - 2
k_lgr_start = ijk_list[4]
k_lgr_end = ijk_list[5] - 2
self.lgr_region.select_box((i_lgr_start, j_lgr_start, k_lgr_start),
(i_lgr_end, j_lgr_end, k_lgr_end))
def set_fluxnum_kw(self):
"""
Initialize FLUXNUM
NB: Can take some time if the grid is large
"""
self.fluxnum_kw.assign(0)
self.inner_region.set_kw(self.fluxnum_kw, 1)
def set_fluxnum_kw_from_file(self, fluxnum_file):
"""
Initialize FLUXNUM from file
NB: Can take some time if the grid is large
"""
if not os.path.isfile(fluxnum_file):
print("ERROR: FLUXNUM input file not found!")
sys.exit(1)
int_type = EclDataType.ECL_INT
with open(fluxnum_file, "r") as file_handle:
self.fluxnum_kw = EclKW.read_grdecl(file_handle,
"FLUXNUM",
ecl_type=int_type)
def get_fluxnum_kw(self):
return self.fluxnum_kw
def include_nnc(self, EGRID_file):
"""
Adds NNC connections to FLUXNUM region.
@EGRID file
This is useful for LGR since LGR region must be one cell away from FLUXNUM
boundaries. If NNC for LGR is outside FLUXNUM, an error will be sent by ECLIPSE.
Needs NNC data from EGRID file.
"""
if EGRID_file[11].header[0] == "NNC1":
NNC1_list = EGRID_file[11]
else:
print("ERROR: NNC info not included in EGRID ...")
if EGRID_file[12].header[0] == "NNC2":
NNC2_list = EGRID_file[12]
else:
print("ERROR: NNC info not included in EGRID ...")
# Checks for NNC pairs. Sets both to 1 if detected in FLUXNUM KW
for i in range(len(NNC1_list)):
nnc1_global_index = NNC1_list[i] - 1 # Converts ECL index
nnc2_global_index = NNC2_list[i] - 1 # Converts ECL index
if self.fluxnum_kw[nnc1_global_index] == 1:
self.fluxnum_kw[nnc2_global_index] = 1
if self.fluxnum_kw[nnc2_global_index] == 1:
self.fluxnum_kw[nnc1_global_index] = 1
def include_well_completions(self,
completion_list,
well_list,
exclude_list=None):
"""
Includes well completions in FLUXNUM keyword.
This is necessary for ECLIPSE to accept
the FLUXNUM region.
@completion_list : List of completions to be included.
@well_list : List of wells to be included
@exclude_list = List of wells to be excluded from the FLUXNUM. Usually empty.
"""
if exclude_list is None:
exclude_list = []
for well in well_list:
include_well = False
temp_g = []
well_index = well_list.index(well)
for pos in completion_list[well_index]:
global_index = self.grid.get_global_index(ijk=pos)
temp_g.append(global_index)
if self.fluxnum_kw[global_index] == 1:
include_well = True
if well in exclude_list:
include_well = False
if include_well:
print(well)
self.included_wells.append(well)
for g in temp_g:
self.fluxnum_kw[g] = 1
def write_fluxnum_kw(self, filename_path):
"""
Writes FLUXNUM keyword to file.
@filename_path : FLUXNUM keyword file
"""
with open(filename_path, "w") as file_handle:
self.fluxnum_kw.write_grdecl(file_handle)
def test_slice(self):
reg = EclRegion(self.grid, False)
reg.select_islice(0, 5)
OK = True
global_list = reg.getGlobalList()
self.assertEqual(global_list.parent(), reg)
for gi in global_list:
(i, j, k) = self.grid.get_ijk(global_index=gi)
if i > 5:
OK = False
self.assertTrue(OK)
self.assertTrue(self.grid.getNY() * self.grid.getNZ() *
6 == len(reg.getGlobalList()))
reg.select_jslice(7, 8, intersect=True)
OK = True
for gi in reg.getGlobalList():
(i, j, k) = self.grid.get_ijk(global_index=gi)
if i > 5:
OK = False
if j < 7 or j > 8:
OK = False
self.assertTrue(OK)
self.assertTrue(2 * self.grid.getNZ() * 6 == len(reg.getGlobalList()))
reg2 = EclRegion(self.grid, False)
reg2.select_kslice(3, 5)
reg &= reg2
OK = True
for gi in reg.getGlobalList():
(i, j, k) = self.grid.get_ijk(global_index=gi)
if i > 5:
OK = False
if j < 7 or j > 8:
OK = False
if k < 3 or k > 5:
OK = False
self.assertTrue(OK)
self.assertTrue(2 * 3 * 6 == len(reg.getGlobalList()))
def test_index_list(self):
reg = EclRegion(self.grid, False)
reg.select_islice(0, 5)
active_list = reg.getActiveList()
global_list = reg.getGlobalList()
def test_layer(self):
region = EclRegion(self.grid, False)
layer = Layer(self.grid.getNX(), self.grid.getNY() + 1)
with self.assertRaises(ValueError):
region.selectFromLayer(layer, 0, 1)
layer = Layer(self.grid.getNX(), self.grid.getNY())
layer[0, 0] = 1
layer[1, 1] = 1
layer[2, 2] = 1
with self.assertRaises(ValueError):
region.selectFromLayer(layer, -1, 1)
with self.assertRaises(ValueError):
region.selectFromLayer(layer, self.grid.getNZ(), 1)
region.selectFromLayer(layer, 0, 2)
glist = region.getGlobalList()
self.assertEqual(0, len(glist))
region.selectFromLayer(layer, 0, 1)
glist = region.getGlobalList()
self.assertEqual(3, len(glist))
