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_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 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 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_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))