def test_actnum_extraction(self): dims = (4, 4, 4) coord = GridGen.create_coord(dims, (1, 1, 1)) zcorn = GridGen.create_zcorn(dims, (1, 1, 1), offset=0) actnum = EclKW("ACTNUM", reduce(operator.mul, dims), EclDataType.ECL_INT) random.seed(1337) for i in range(len(actnum)): actnum[i] = random.randint(0, 1) grid = EclGrid.create(dims, zcorn, coord, actnum) ijk_bounds = generate_ijk_bounds(dims) for ijk_bound in ijk_bounds: if not decomposition_preserving(ijk_bound): continue sub = GridGen.extract_subgrid_data(dims, coord, zcorn, ijk_bound, actnum=actnum) sub_coord, sub_zcorn, sub_actnum = sub sub_dims = tuple([u - l + 1 for l, u in ijk_bound]) subgrid = EclGrid.create(sub_dims, sub_zcorn, sub_coord, sub_actnum) self.assertEqual(sub_dims, subgrid.getDims()[:-1:]) self.assertSubgrid(grid, subgrid, ijk_bound)
def test_export(self): dims = (3, 3, 3) coord = GridGen.create_coord(dims, (1, 1, 1)) zcorn = GridGen.create_zcorn(dims, (1, 1, 1), offset=0) grid = EclGrid.create(dims, zcorn, coord, None) self.assertEqual(zcorn, grid.export_zcorn()) self.assertEqual(coord, grid.export_coord())
def test_create(self): with self.assertRaises(ValueError): grid = GridGen.createRectangular( (10,20,30) , (1,1,1) , actnum = [0,1,1,2]) with self.assertRaises(ValueError): grid = GridGen.createRectangular( (10,20,30) , (1,1,1) , actnum = IntVector(initial_size = 10)) actnum = IntVector(default_value = 1 , initial_size = 6000) actnum[0] = 0 actnum[1] = 0 grid = GridGen.createRectangular( (10,20,30) , (1,1,1) , actnum = actnum) self.assertEqual( grid.getNumActive( ) , 30*20*10 - 2)
def createContainmentTestBase(): return [ (3, GridGen.createGrid((6,6,6), (1,1,1), offset=1)), (10, GridGen.createGrid((3,3,3), (1,1,1), offset=1, concave=True)), (4, GridGen.createGrid((10,10,1), (1,1,1), offset=0., misalign=True)), (3, GridGen.createGrid((6,6,6), (1,1,1), offset=0., escape_origo_shift=(100, 100, 0), irregular_offset=True, concave=True, irregular=True, scale=1.5, translation=(5,5,0), misalign=True ) ) ]
def test_subgrid_translation(self): grid = GridGen.create_grid((4, 4, 4), (1, 1, 1), offset=0.5, irregular=True, irregular_offset=True, concave=True, translation=(10, 10, 0)) # Create grid with MAPAXES mapaxes = EclKW("MAPAXES", 6, EclDataType.ECL_FLOAT) for i, val in enumerate([1200, 1400, 2500, 2500, 3700, 4000]): mapaxes[i] = val grid = EclGrid.create(grid.getDims(), grid.export_zcorn(), grid.export_coord(), None, mapaxes=mapaxes) for translation in [(0, 0, 0), (10, 10, 100), (-1, -1, -1)]: subgrid = GridGen.extract_subgrid(grid, ((0, 3), (0, 3), (0, 3)), translation=translation) self.assertEqual(grid.getDims(), subgrid.getDims()) translation = numpy.array(translation) for gindex in range(grid.getGlobalSize()): grid_corners = [ grid.getCellCorner(i, global_index=gindex) for i in range(8) ] subgrid_corners = [ subgrid.getCellCorner(i, global_index=gindex) for i in range(8) ] subgrid_corners = [ list(numpy.array(corner) - translation) for corner in subgrid_corners ] for gc, sc in zip(grid_corners, subgrid_corners): self.assertAlmostEqualList( gc, sc, msg="Failed to translate corners correctly." + "Expected %s, was %s." % (gc, sc), tolerance=10e-10)
def test_oom_grid(self): nx = 2000 ny = 2000 nz = 2000 with self.assertRaises(MemoryError): grid = GridGen.createRectangular( (nx,ny,nz), (1,1,1))
def test_numpy3D(self): nx = 10 ny = 7 nz = 5 grid = GridGen.createRectangular((nx,ny,nz) , (1,1,1)) kw = EclKW( "SWAT" , nx*ny*nz , EclDataType.ECL_FLOAT ) numpy_3d = grid.create3D( kw )
def test_cell_corner_containment_compatability(self): grid = GridGen.createRectangular((3, 3, 3), (1, 1, 1)) for x, y, z in itertools.product(range(4), repeat=3): for i in range(27): if grid.cell_contains(x, y, z, i): self.assertEqual(CORNER_HOME[(x, y, z)], i)
def test_output_units(self): n = 10 a = 1 grid = GridGen.createRectangular( (n,n,n), (a,a,a)) with TestAreaContext("python/ecl_grid/units"): grid.save_EGRID( "CASE.EGRID" , output_unit = EclUnitTypeEnum.ECL_FIELD_UNITS ) f = EclFile("CASE.EGRID") g = f["GRIDUNIT"][0] self.assertEqual( g[0].strip( ) , "FEET" ) g2 = EclGrid("CASE.EGRID") self.assertFloatEqual( g2.cell_volume( global_index = 0 ) , 3.28084*3.28084*3.28084) grid.save_EGRID( "CASE.EGRID" ) f = EclFile("CASE.EGRID") g = f["GRIDUNIT"][0] self.assertEqual( g[0].strip( ) , "METRES" ) grid.save_EGRID( "CASE.EGRID" , output_unit = EclUnitTypeEnum.ECL_LAB_UNITS) f = EclFile("CASE.EGRID") g = f["GRIDUNIT"][0] self.assertEqual( g[0].strip() , "CM" ) g2 = EclGrid("CASE.EGRID") self.assertFloatEqual( g2.cell_volume( global_index = 0 ) , 100*100*100 )
def test_dims(self): grid = GridGen.createRectangular( (10,20,30) , (1,1,1) ) self.assertEqual( grid.getNX() , 10 ) self.assertEqual( grid.getNY() , 20 ) self.assertEqual( grid.getNZ() , 30 ) self.assertEqual( grid.getGlobalSize() , 30*10*20 ) self.assertEqual( grid.getDims() , (10,20,30,6000) )
def test_extract_grid_slice_spec(self): dims = (4, 4, 4) zcorn = list(GridGen.create_zcorn(dims, (1, 1, 1), offset=0)) coord = list(GridGen.create_coord(dims, (1, 1, 1))) ijk_bounds = generate_ijk_bounds(dims) for ijk in ijk_bounds: ijk = list(ijk) for i in range(3): if len(set(ijk[i])) == 1: ijk[i] = ijk[i][0] GridGen.extract_subgrid_data(dims, coord, zcorn, ijk, decomposition_change=True)
def test_compressed_copy(self): nx = 10 ny = 10 nz = 10 grid = GridGen.createRectangular( (nx,ny,nz) , (1,1,1) ) kw1 = EclKW("KW" , 1001 , EclDataType.ECL_INT ) with self.assertRaises(ValueError): cp = grid.compressedKWCopy( kw1 )
def test_concvex_cell_containment(self): points = [ (10, 10, 10), (25, 5, 5), (5, 25, 5), (20, 20, 10), (5, 5, 25), (20, 10, 20), (10, 20, 20), (25, 25, 25) ] grid = GridGen.createSingleCellGrid(points) assertPoint = lambda p : self.assertTrue( grid.cell_contains(p[0], p[1], p[2], 0) ) assertNotPoint = lambda p : self.assertFalse( grid.cell_contains(p[0], p[1], p[2], 0) ) # Cell center assertPoint(average(points)); # "Side" center assertPoint(average(points[0:4:])) assertPoint(average(points[4:8:])) assertPoint(average(points[1:8:2])) assertPoint(average(points[0:8:2])) assertPoint(average(points[0:8:4] + points[1:8:4])) assertPoint(average(points[2:8:4] + points[3:8:4])) # Corners for p in points: assertPoint(p) # Edges edges = ([(i, i+1) for i in range(0, 8, 2)] + [(i, i+2) for i in [0, 1, 4, 5]] + [(i, i+4) for i in range(4)] + [(1,2), (2,7), (1,7), (4,7), (2,4), (4,1)]) for a,b in edges: assertPoint(average([points[a], points[b]])) # Epsilon inside from corners middle_point = average(points) for p in points: assertPoint(average(20*[p] + [middle_point])) # Espilon outside middle_point[2] = 0 for p in points[0:4:]: assertNotPoint(average(20*[p] + [middle_point])) middle_point[2] = 30 for p in points[4:8:]: assertNotPoint(average(20*[p] + [middle_point]))
def test_cell_corner_containment(self): n = 4 d = 10 grid = GridGen.createRectangular((n, n, n), (d, d, d)) for x, y, z in itertools.product(range(0, n * d + 1, d), repeat=3): self.assertEqual(1, [ grid.cell_contains(x, y, z, i) for i in range(n**3) ].count(True))
def test_dxdydz(self): nx = 10 ny = 10 nz = 10 grid = GridGen.createRectangular( (nx,ny,nz) , (2,3,4) ) (dx,dy,dz) = grid.getCellDims( active_index = 0 ) self.assertEqual( dx , 2 ) self.assertEqual( dy , 3 ) self.assertEqual( dz , 4 )
def test_create(self): grid = EclGridGenerator.create_rectangular( (10,10,10) , (1,1,1)) with TestAreaContext( "grid"): grid.save_EGRID( "TEST.EGRID") f = GridFile( input_name = "TEST.EGRID") with open("TEST.EGRID") as grid_file: f.content.save( "TEST.EGRID" , File( grid_file )) grid = f.data() self.assertTrue( isinstance(grid, EclGrid ))
def test_truncated_file(self): grid = GridGen.createRectangular( (10,20,30) , (1,1,1) ) with TestAreaContext("python/ecl_grid/truncated"): grid.save_EGRID( "TEST.EGRID") size = os.path.getsize( "TEST.EGRID") with open("TEST.EGRID" , "r+") as f: f.truncate( size / 2 ) with self.assertRaises(IOError): EclGrid("TEST.EGRID")
def test_posXY1(self): nx = 4 ny = 1 nz = 1 grid = GridGen.createRectangular( (nx,ny,nz) , (1,1,1) ) (i,j) = grid.findCellXY( 0.5 , 0.5, 0 ) self.assertEqual(i , 0) self.assertEqual(j , 0) (i,j) = grid.findCellXY( 3.5 , 0.5, 0 ) self.assertEqual(i , 3) self.assertEqual(j , 0)
def test_cell_face_containment(self): n = 4 d = 10 grid = GridGen.createRectangular( (n, n, n), (d, d, d)) for x, y, z in itertools.product(range(d/2, n*d, d), repeat=3): for axis, direction in itertools.product(range(3), [-1, 1]): p = [x, y, z] p[axis] = p[axis] + direction*d/2 self.assertEqual( 1, [grid.cell_contains(p[0], p[1], p[2], i) for i in range(n**3)].count(True) )
def test_subgrid_extration(self): for _, _, grid in self.test_base[:-1:]: grid_dims = grid.getDims()[:-1:] ijk_bounds = generate_ijk_bounds(grid_dims) for ijk_bound in ijk_bounds: if not decomposition_preserving(ijk_bound): continue sub_dims = tuple([u - l + 1 for l, u in ijk_bound]) subgrid = GridGen.extract_subgrid(grid, ijk_bound) self.assertEqual(sub_dims, subgrid.getDims()[:-1:]) self.assertSubgrid(grid, subgrid, ijk_bound)
def test_len(self): nx = 10 ny = 11 nz = 12 actnum = EclKW( "ACTNUM" , nx*ny*nz , EclDataType.ECL_INT ) actnum[0] = 1 actnum[1] = 1 actnum[2] = 1 actnum[3] = 1 grid = GridGen.createRectangular( (nx,ny,nz) , (1,1,1), actnum = actnum) self.assertEqual( len(grid) , nx*ny*nz ) self.assertEqual( grid.getNumActive( ) , 4 )
def test_node_pos(self): grid = GridGen.createRectangular( (10,20,30) , (1,1,1) ) with self.assertRaises(IndexError): grid.getNodePos(-1,0,0) with self.assertRaises(IndexError): grid.getNodePos(11,0,0) p0 = grid.getNodePos(0,0,0) self.assertEqual( p0 , (0,0,0)) p7 = grid.getNodePos(10,20,30) self.assertEqual( p7 , (10,20,30))
def test_translation(self): dims = (3, 3, 3) coord = GridGen.create_coord(dims, (1, 1, 1)) zcorn = GridGen.create_zcorn(dims, (1, 1, 1), offset=0) grid = EclGrid.create(dims, zcorn, coord, None) ijk_bound = [(0, d - 1) for d in dims] translation = (1, 2, 3) sub_coord, sub_zcorn, _ = GridGen.extract_subgrid_data( dims, coord, zcorn, ijk_bound, translation=translation) tgrid = EclGrid.create(dims, sub_zcorn, sub_coord, None) self.assertEqual(grid.getGlobalSize(), tgrid.getGlobalSize()) for gi in range(grid.getGlobalSize()): translation = numpy.array(translation) corners = [grid.getCellCorner(i, gi) for i in range(8)] corners = [tuple(numpy.array(c) + translation) for c in corners] tcorners = [tgrid.getCellCorner(i, gi) for i in range(8)] self.assertEqual(corners, tcorners)
def test_extract_grid_invalid_bounds(self): dims = (3, 3, 3) zcorn = list(GridGen.create_zcorn(dims, (1, 1, 1), offset=0)) coord = list(GridGen.create_coord(dims, (1, 1, 1))) with self.assertRaises(ValueError): GridGen.extract_subgrid_data(dims, coord, zcorn, ((-1, 0), (2, 2), (2, 2))) with self.assertRaises(ValueError): GridGen.extract_subgrid_data(dims, coord, zcorn, ((1, 6), (2, 2), (2, 2))) with self.assertRaises(ValueError): GridGen.extract_subgrid_data(dims, coord, zcorn, ((1, 2), (2, 0), (2, 2)))
def test_repr_and_name(self): grid = GridGen.createRectangular((2,2,2), (10,10,10), actnum=[0,0,0,0,1,1,1,1]) pfx = 'EclGrid(' rep = repr(grid) self.assertEqual(pfx, rep[:len(pfx)]) self.assertEqual(type(rep), type('')) self.assertEqual(type(grid.getName()), type('')) with TestAreaContext("python/ecl_grid/repr"): grid.save_EGRID("CASE.EGRID") g2 = EclGrid("CASE.EGRID") r2 = repr(g2) self.assertEqual(pfx, r2[:len(pfx)]) self.assertEqual(type(r2), type('')) self.assertEqual(type(g2.getName()), type(''))
def test_validate_cells(self): for coord, zcorn, grid in self.test_base: grid_dims = grid.getDims()[:-1:] ijk_bounds = generate_ijk_bounds(grid_dims) for ijk_bound in ijk_bounds: if not decomposition_preserving(ijk_bound): continue sub_dims = tuple([u - l + 1 for l, u in ijk_bound]) sub_coord, sub_zcorn, _ = GridGen.extract_subgrid_data( grid_dims, coord, zcorn, ijk_bound) subgrid = EclGrid.create(sub_dims, sub_zcorn, sub_coord, None) self.assertEqual(sub_dims, subgrid.getDims()[:-1:]) self.assertSubgrid(grid, subgrid, ijk_bound)
def createWrapperGrid(grid): """ Creates a grid that occupies the same space as the given grid, but that consists of a single cell. """ x, y, z = grid.getNX() - 1, grid.getNY() - 1, grid.getNZ() - 1 corner_pos = [(0, 0, 0), (x, 0, 0), (0, y, 0), (x, y, 0), (0, 0, z), (x, 0, z), (0, y, z), (x, y, z)] corners = [ grid.getCellCorner(i, ijk=pos) for i, pos in enumerate(corner_pos) ] return GridGen.create_single_cell_grid(corners)
def test_init_ACTNUM(self): nx = 10 ny = 23 nz = 7 grid = GridGen.createRectangular( (nx,ny,nz) , (1,1,1) ) actnum = grid.exportACTNUM() self.assertEqual( len(actnum) , nx*ny*nz ) self.assertEqual( actnum[0] , 1 ) self.assertEqual( actnum[nx*ny*nz - 1] , 1 ) actnum_kw = grid.exportACTNUMKw( ) self.assertEqual(len(actnum_kw) , len(actnum)) for a1,a2 in zip(actnum, actnum_kw): self.assertEqual(a1, a2)
def test_extract_grid_decomposition_change(self): dims = (4, 4, 4) zcorn = list(GridGen.create_zcorn(dims, (1, 1, 1), offset=0)) coord = list(GridGen.create_coord(dims, (1, 1, 1))) ijk_bounds = generate_ijk_bounds(dims) for ijk_bounds in ijk_bounds: if decomposition_preserving(ijk_bounds): GridGen.extract_subgrid_data(dims, coord, zcorn, ijk_bounds) else: with self.assertRaises(ValueError): GridGen.extract_subgrid_data(dims, coord, zcorn, ijk_bounds) GridGen.extract_subgrid_data(dims, coord, zcorn, ijk_bounds, decomposition_change=True)
def test_posXYEdge(self): nx = 10 ny = 11 grid = GridGen.createRectangular( (nx,ny,1) , (1,1,1) ) self.assertEqual( grid.findCellCornerXY(0,0,0) , 0 ) self.assertEqual( grid.findCellCornerXY(nx,0,0) , nx) self.assertEqual( grid.findCellCornerXY(0 , ny , 0) , (nx + 1 ) * ny ) self.assertEqual( grid.findCellCornerXY(nx,ny,0) , (nx + 1 ) * (ny + 1) - 1) self.assertEqual( grid.findCellCornerXY(0.25,0,0) , 0 ) self.assertEqual( grid.findCellCornerXY(0,0.25,0) , 0 ) self.assertEqual( grid.findCellCornerXY(nx - 0.25,0,0) , nx ) self.assertEqual( grid.findCellCornerXY(nx , 0.25,0) , nx ) self.assertEqual( grid.findCellCornerXY(0 , ny - 0.25, 0) , (nx + 1 ) * ny ) self.assertEqual( grid.findCellCornerXY(0.25 , ny , 0) , (nx + 1 ) * ny ) self.assertEqual( grid.findCellCornerXY(nx -0.25 ,ny,0) , (nx + 1 ) * (ny + 1) - 1) self.assertEqual( grid.findCellCornerXY(nx , ny - 0.25,0) , (nx + 1 ) * (ny + 1) - 1)