def test_add_polyline_barrier2(self): grid = EclGrid.create_rectangular((10, 10, 1), (1, 1, 1)) layer = FaultBlockLayer(self.grid, 0) polyline = Polyline(init_points=[(0.1, 0.9), (8.9, 0.9), (8.9, 8.9)]) points = [ ((0, 0), (0, 1)), ((2, 0), (2, 1)), ((4, 0), (4, 1)), ((6, 0), (6, 1)), ((8, 0), (8, 1)), # ((8, 1), (9, 1)), ((8, 3), (9, 3)), ((8, 5), (9, 5)), ((8, 7), (9, 7)) ] geo_layer = layer.getGeoLayer() for p1, p2 in points: self.assertTrue(geo_layer.cellContact(p1, p2)) layer.addPolylineBarrier(polyline) for p1, p2 in points: print p1, p2 self.assertFalse(geo_layer.cellContact(p1, p2))
def test_polyline_intersection(self): grid = EclGrid.create_rectangular((100, 100, 10), (0.25, 0.25, 1)) # Fault1 Fault4 # | | # | | # | | # | ------- Fault2 | # | | # | | # (5 , 2.50) # -------- Fault3 # fault1 = Fault(grid, "Fault1") fault2 = Fault(grid, "Fault2") fault3 = Fault(grid, "Fault3") fault4 = Fault(grid, "Fault4") fault1.addRecord(1, 1, 10, grid.getNY() - 1, 0, 0, "X") fault2.addRecord(5, 10, 15, 15, 0, 0, "Y") fault3.addRecord(5, 10, 5, 5, 0, 0, "Y") fault4.addRecord(20, 20, 10, grid.getNY() - 1, 0, 0, "X") polyline = Polyline(init_points=[(4, 4), (8, 4)]) self.assertTrue(fault4.intersectsPolyline(polyline, 0)) cpolyline = CPolyline(init_points=[(4, 4), (8, 4)]) self.assertTrue(fault4.intersectsPolyline(cpolyline, 0)) polyline = Polyline(init_points=[(8, 4), (16, 4)]) self.assertFalse(fault4.intersectsPolyline(polyline, 0)) cpolyline = CPolyline(init_points=[(8, 4), (16, 4)]) self.assertFalse(fault4.intersectsPolyline(cpolyline, 0))
def test_get_ijk(self): with TestAreaContext("python/fault_block_layer/neighbour") as work_area: with open("kw.grdecl","w") as fileH: fileH.write("FAULTBLK \n") fileH.write("1 1 1 0 0\n") fileH.write("1 2 2 0 3\n") fileH.write("4 2 2 3 3\n") fileH.write("4 4 4 0 0\n") fileH.write("4 4 4 0 5\n") fileH.write("/\n") kw = EclKW.read_grdecl(open("kw.grdecl") , "FAULTBLK" , ecl_type = EclTypeEnum.ECL_INT_TYPE) grid = EclGrid.create_rectangular( (5,5,1) , (1,1,1) ) layer = FaultBlockLayer( grid , 0 ) layer.loadKeyword( kw ) block = layer[0,0] self.assertEqual( block.getBlockID() , 1 ) block = layer[2,2] self.assertEqual( block.getBlockID() , 2 ) with self.assertRaises(ValueError): layer[3,3] with self.assertRaises(IndexError): layer[5,5]
def test_contact(self): grid = EclGrid.create_rectangular( (100,100,10) , (1,1,1)) # Fault1 Fault4 # | | # | | # | | # | ----------------------+-- Fault2 # | | # | | # # -------- Fault3 # fault1 = Fault(grid , "Fault1") fault2 = Fault(grid , "Fault2") fault3 = Fault(grid , "Fault3") fault4 = Fault(grid , "Fault4") fault1.addRecord(1 , 1 , 10 , grid.getNY() - 1 , 0 , 0 , "X") fault2.addRecord(5 , 30 , 15 , 15 , 0 , 0 , "Y") fault3.addRecord(2 , 10 , 9 , 9 , 0 , 0 , "Y") fault4.addRecord(20 , 20 , 10 , grid.getNY() - 1 , 0 , 0 , "X") #self.assertFalse( fault1.intersectsFault(fault2 , 0) ) #self.assertFalse( fault2.intersectsFault(fault1 , 0) ) #self.assertTrue( fault2.intersectsFault(fault4 , 0) ) #self.assertTrue( fault4.intersectsFault(fault2 , 0) ) self.assertTrue( fault1.intersectsFault(fault1 , 0) )
def test_join_faults(self): grid = EclGrid.create_rectangular( (100,100,10) , (1,1,1)) # Fault1 Fault4 # | | # | | # | | # | ------- Fault2 | # | | # | | # # -------- Fault3 # fault1 = Fault(grid , "Fault1") fault2 = Fault(grid , "Fault2") fault3 = Fault(grid , "Fault3") fault4 = Fault(grid , "Fault4") fault1.addRecord(1 , 1 , 10 , grid.getNY() - 1 , 0 , 0 , "X") fault2.addRecord(5 , 10 , 15 , 15 , 0 , 0 , "Y") fault3.addRecord(5 , 10 , 5 , 5 , 0 , 0 , "Y") fault4.addRecord(20 , 20 , 10 , grid.getNY() - 1 , 0 , 0 , "X") rays = fault1.getEndRays(0) self.assertEqual( rays[0] , [(2,10) , (0,-1)]) self.assertEqual( rays[1] , [(2,100) , (0,1)]) extra = Fault.joinFaults( fault1 , fault3 , 0) self.assertEqual( extra , [(2,10) , (2,6) , (5,6)] )
def test_extend_polyline_on(self): grid = EclGrid.create_rectangular( (3,3,1) , (1 , 1 , 1)) # o o o o # # o---o---o---o # # o===o===o===o # # o o o o fault1 = Fault(grid , "Fault") fault1.addRecord(0 , 2 , 0 , 0 , 0 , 0 , "Y") polyline0 = CPolyline( init_points = [(0,2)]) polyline1 = CPolyline( init_points = [(0,2) , (3,2)]) polyline2 = CPolyline( init_points = [(1,3) , (1,2)]) polyline3 = CPolyline( init_points = [(1,3) , (1,0)]) with self.assertRaises(ValueError): fault1.extendPolylineOnto( polyline0 , 0 ) points = fault1.extendPolylineOnto( polyline1 , 0 ) self.assertIsNone( points ) points = fault1.extendPolylineOnto( polyline2 , 0) self.assertEqual( points , [(1,2) , (1,1)]) points = fault1.extendPolylineOnto( polyline3 , 0) self.assertIsNone( points )
def test_extend_to_polyline(self): grid = EclGrid.create_rectangular( (3,3,1) , (1 , 1 , 1)) # o o o o # # o---o---o---o # # o===+ o o # | # o o o o fault1 = Fault(grid , "Fault") fault1.addRecord(0 , 0 , 0 , 0 , 0 , 0 , "X-") fault1.addRecord(0 , 0 , 0 , 0 , 0 , 0 , "Y") polyline = CPolyline( init_points = [(0,2) , (3,2)]) points = fault1.extendToPolyline( polyline , 0 ) self.assertEqual( points , [(1,1) , (2,2)]) end_join = fault1.endJoin( polyline , 0 ) self.assertEqual( end_join, [(1,1) , (0,2)] ) polyline2 = CPolyline( init_points = [(0.8,2) , (0.8,0.8)]) end_join = fault1.endJoin( polyline2 , 0 ) self.assertIsNone( end_join )
def test_polyline_intersection(self): grid = EclGrid.create_rectangular((100, 100, 10), (0.25, 0.25, 1)) # Fault1 Fault4 # | | # | | # | | # | ------- Fault2 | # | | # | | # (5 , 2.50) # -------- Fault3 # fault1 = Fault(grid, "Fault1") fault2 = Fault(grid, "Fault2") fault3 = Fault(grid, "Fault3") fault4 = Fault(grid, "Fault4") fault1.addRecord(1, 1, 10, grid.getNY() - 1, 0, 0, "X") fault2.addRecord(5, 10, 15, 15, 0, 0, "Y") fault3.addRecord(5, 10, 5, 5, 0, 0, "Y") fault4.addRecord(20, 20, 10, grid.getNY() - 1, 0, 0, "X") polyline = Polyline(init_points=[(4, 4), (8, 4)]) self.assertTrue(fault4.intersectsPolyline(polyline, 0)) cpolyline = CPolyline(init_points=[(4, 4), (8, 4)]) self.assertTrue(fault4.intersectsPolyline(cpolyline, 0)) polyline = Polyline(init_points=[(8, 4), (16, 4)]) self.assertFalse(fault4.intersectsPolyline(polyline, 0)) cpolyline = CPolyline(init_points=[(8, 4), (16, 4)]) self.assertFalse(fault4.intersectsPolyline(cpolyline, 0))
def test_connectWithPolyline(self): grid = EclGrid.create_rectangular( (4,4,1) , (1 , 1 , 1)) # o o o o o # # o o o o o # # o---o---o---o---o # # o o o o o # | # o o o o o fault1 = Fault(grid , "Fault1") fault1.addRecord(0 , 3 , 1 , 1 , 0 , 0 , "Y") fault2 = Fault(grid , "Fault2") fault2.addRecord(1 , 1 , 0 , 0 , 0 , 0 , "X") fault3 = Fault(grid , "Fault3") fault3.addRecord(1 , 1 , 0 , 2 , 0 , 0 , "X") self.assertIsNone( fault3.connect( fault1 , 0 )) intersect = fault2.connect( fault1 , 0 ) self.assertEqual( len(intersect) , 2 ) p1 = intersect[0] p2 = intersect[1] self.assertEqual( p1 , (2,1)) self.assertEqual( p2 , (2,2))
def test_rect(self): with TestAreaContext("python/grid-test/testRect"): a1 = 1.0 a2 = 2.0 a3 = 3.0 grid = EclGrid.create_rectangular((9, 9, 9), (a1, a2, a3)) grid.save_EGRID("rect.EGRID") grid2 = EclGrid("rect.EGRID") self.assertTrue(grid) self.assertTrue(grid2) (x, y, z) = grid.get_xyz(ijk=(4, 4, 4)) self.assertAlmostEqualList([x, y, z], [4.5 * a1, 4.5 * a2, 4.5 * a3]) v = grid.cell_volume(ijk=(4, 4, 4)) self.assertAlmostEqualScaled(v, a1 * a2 * a3) z = grid.depth(ijk=(4, 4, 4 )) self.assertAlmostEqualScaled(z, 4.5 * a3) g1 = grid.global_index(ijk=(2, 2, 2)) g2 = grid.global_index(ijk=(4, 4, 4)) (dx, dy, dz) = grid.distance(g2, g1) self.assertAlmostEqualList([dx, dy, dz], [2 * a1, 2 * a2, 2 * a3]) self.assertTrue(grid.cell_contains(2.5 * a1, 2.5 * a2, 2.5 * a3, ijk=(2, 2, 2))) ijk = grid.find_cell(1.5 * a1, 2.5 * a2, 3.5 * a3) self.assertAlmostEqualList(ijk, [1, 2, 3])
def test_neighbour_cells(self): nx = 10 ny = 8 nz = 7 grid = EclGrid.create_rectangular((nx, ny, nz), (1, 1, 1)) faults_file = self.createTestPath("local/ECLIPSE/FAULTS/faults_nb.grdecl") faults = FaultCollection(grid, faults_file) fault = faults["FY"] self.assertEqual(len(fault), 1) fault_layer = fault[0] fl1 = fault_layer[0] nb_cells1 = fl1.getNeighborCells() true_nb_cells1 = [(0, nx), (1, nx + 1), (2, nx + 2), (3, nx + 3), (4, nx + 4)] self.assertListEqual(nb_cells1, true_nb_cells1) fl2 = fault_layer[1] nb_cells2 = fl2.getNeighborCells() true_nb_cells2 = [(6, nx + 6), (7, nx + 7), (8, nx + 8), (9, nx + 9)] self.assertListEqual(nb_cells2, true_nb_cells2) nb_cells = fault_layer.getNeighborCells() self.assertListEqual(nb_cells, true_nb_cells1 + true_nb_cells2) fault = faults["FY0"] fault_layer = fault[0] fl1 = fault_layer[0] nb_cells1 = fl1.getNeighborCells() true_nb_cells1 = [(-1, 0), (-1, 1), (-1, 2)] self.assertListEqual(nb_cells1, true_nb_cells1) fault = faults["FYNY"] fault_layer = fault[0] fl1 = fault_layer[0] nb_cells1 = fl1.getNeighborCells() true_nb_cells1 = [(nx * (ny - 1), -1), (nx * (ny - 1) + 1, -1), (nx * (ny - 1) + 2, -1)] self.assertListEqual(nb_cells1, true_nb_cells1) fault = faults["FX"] fault_layer = fault[0] fl1 = fault_layer[0] nb_cells1 = fl1.getNeighborCells() true_nb_cells1 = [(0, 1), (nx, nx + 1), (2 * nx, 2 * nx + 1)] self.assertListEqual(nb_cells1, true_nb_cells1) fault = faults["FX0"] fault_layer = fault[0] fl1 = fault_layer[0] nb_cells1 = fl1.getNeighborCells() true_nb_cells1 = [(-1, 0), (-1, nx), (-1, 2 * nx)] self.assertListEqual(nb_cells1, true_nb_cells1) fault = faults["FXNX"] fault_layer = fault[0] fl1 = fault_layer[0] nb_cells1 = fl1.getNeighborCells() true_nb_cells1 = [(nx - 1, -1), (2 * nx - 1, -1), (3 * nx - 1, -1)] self.assertListEqual(nb_cells1, true_nb_cells1)
def test_fault_barrier(self): nx = 120 ny = 60 nz = 43 grid = EclGrid.create_rectangular( (nx , ny , nz) , (1,1,1) ) with TestAreaContext("python/faults/line_order"): with open("faults.grdecl" , "w") as f: f.write("""FAULTS \'F\' 105 107 50 50 1 43 \'Y\' / \'F\' 108 108 50 50 1 43 \'X\' / \'F\' 108 108 50 50 22 43 \'Y\' / \'F\' 109 109 49 49 1 43 \'Y\' / \'F\' 110 110 49 49 1 43 \'X\' / \'F\' 111 111 48 48 1 43 \'Y\' / / """) with open("faults.grdecl") as f: faults = FaultCollection( grid , "faults.grdecl" ) # Fault layout: # # +---+---+---+---+ # | # +---+ + # | # +---+ fault = faults["F"] layer = Layer(nx,ny) fault_pairs = [((104,49),(104,50)), ((105,49),(105,50)), ((106,49),(106,50)), ((107,49),(108,49)), ((107,49),(107,50)), ((108,48),(108,49)), ((109,48),(110,48)), ((110,47),(110,48))] gap_pair = ((109,48),(109,49)) for p1,p2 in fault_pairs: self.assertTrue(layer.cellContact( p1 , p2 )) p1,p2 = gap_pair self.assertTrue(layer.cellContact( p1 , p2 )) layer.addFaultBarrier(fault , 30 , link_segments = False) for p1,p2 in fault_pairs: self.assertFalse(layer.cellContact( p1 , p2 )) p1,p2 = gap_pair self.assertTrue(layer.cellContact( p1 , p2 )) layer.addFaultBarrier(fault , 30) p1,p2 = gap_pair self.assertFalse(layer.cellContact( p1 , p2 ))
def test_plot_block_data_vector(self): grid = EclGrid.create_rectangular((10, 10, 10), (1, 1, 1)) config_node = EnkfConfigNode.createFieldConfigNode("FIELD", grid) config_node.updateStateField(EnkfTruncationType.TRUNCATE_NONE, 0, 0) obs_vector = ObsVector(EnkfObservationImplementationType.BLOCK_OBS, "OBS", config_node, 100) pbv = PlotBlockVector(obs_vector, 0) self.assertEqual(len(pbv), 0)
def test_boundingBox(self): grid = EclGrid.create_rectangular((10,10,10) , (1,1,1)) with self.assertRaises(ValueError): bbox = grid.getBoundingBox2D(layer = -1 ) with self.assertRaises(ValueError): bbox = grid.getBoundingBox2D( layer = 11 ) bbox = grid.getBoundingBox2D( layer = 10 ) self.assertEqual( bbox , ((0,0) , (10, 0) , (10 , 10) , (0,10)))
def test_fault_block_edge(self): grid = EclGrid.create_rectangular( (5,5,1) , (1,1,1) ) kw = EclKW.create( "FAULTBLK" , grid.size , EclTypeEnum.ECL_INT_TYPE ) kw.assign( 0 ) for j in range(1,4): for i in range(1,4): g = i + j*grid.getNX() kw[g] = 1 layer = FaultBlockLayer( grid , 0 )
def test_connect_faults(self): grid = EclGrid.create_rectangular( (100,100,10) , (1,1,1)) # Fault1 Fault4 # | | # | | # | | # | ------- Fault2 | # | | # | | # # -------- Fault3 # fault1 = Fault(grid , "Fault1") fault2 = Fault(grid , "Fault2") fault3 = Fault(grid , "Fault3") fault4 = Fault(grid , "Fault4") fault1.addRecord(1 , 1 , 10 , grid.getNY() - 1 , 0 , 0 , "X") fault2.addRecord(5 , 10 , 15 , 15 , 0 , 0 , "Y") fault3.addRecord(5 , 10 , 5 , 5 , 0 , 0 , "Y") fault4.addRecord(20 , 20 , 10 , grid.getNY() - 1 , 0 , 0 , "X") for other_fault in [fault2 , fault3,fault4]: with self.assertRaises(ValueError): fault1.extendToFault( other_fault ,0) with self.assertRaises(ValueError): fault2.extendToFault( fault3 , 0) for other_fault in [fault1 , fault2,fault4]: with self.assertRaises(ValueError): fault3.extendToFault( other_fault ,0 ) for other_fault in [fault1 , fault2,fault3]: with self.assertRaises(ValueError): fault4.extendToFault( other_fault , 0) ext21 = fault2.extendToFault( fault1 , 0) self.assertEqual(len(ext21) , 2) p0 = ext21[0] p1 = ext21[1] self.assertEqual(p0 , (5 , 16)) self.assertEqual(p1 , (2 , 16)) ext24 = fault2.extendToFault( fault4,0 ) self.assertEqual(len(ext24) , 2) p0 = ext24[0] p1 = ext24[1] self.assertEqual(p0 , (11 , 16)) self.assertEqual(p1 , (21 , 16))
def setUp(self): self.grid = EclGrid.create_rectangular( (10,10,10) , (1,1,1) ) self.kw = EclKW.create( "FAULTBLK" , self.grid.size , EclTypeEnum.ECL_INT_TYPE ) 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_PolylineIJ(self): nx = 10 ny = 10 nz = 10 grid = EclGrid.create_rectangular( (nx,ny,nz) , (0.1,0.1,0.1)) f = Fault(grid , "F") f.addRecord(0 , 1 , 0 , 0 , 0,0 , "Y-") f.addRecord(2 , 2 , 0 , 1 , 0,0 , "X-") f.addRecord(2 , 2 , 1 , 1 , 0,0 , "Y") pl = f.getIJPolyline( 0 ) self.assertEqual(pl , [(0,0) , (2,0) , (2,2) , (3,2)])
def test_neighbours(self): with TestAreaContext( "python/fault_block_layer/neighbour") as work_area: with open("kw.grdecl", "w") as fileH: fileH.write("FAULTBLK \n") fileH.write("1 1 1 0 0\n") fileH.write("1 2 2 0 3\n") fileH.write("4 2 2 3 3\n") fileH.write("4 4 4 0 0\n") fileH.write("4 4 4 0 5\n") fileH.write("/\n") kw = EclKW.read_grdecl(open("kw.grdecl"), "FAULTBLK", ecl_type=EclTypeEnum.ECL_INT_TYPE) grid = EclGrid.create_rectangular((5, 5, 1), (1, 1, 1)) layer = FaultBlockLayer(grid, 0) layer.loadKeyword(kw) block1 = layer.getBlock(1) block2 = layer.getBlock(2) block3 = layer.getBlock(3) block4 = layer.getBlock(4) block5 = layer.getBlock(5) self.assertEqual(block1.getParentLayer(), layer) #Expected: 1 -> {2,4}, 2 -> {1,3,4}, 3 -> {2}, 4 -> {1,2}, 5-> {} neighbours = block1.getNeighbours() self.assertEqual(len(neighbours), 2) self.assertTrue(block2 in neighbours) self.assertTrue(block4 in neighbours) neighbours = block2.getNeighbours() self.assertEqual(len(neighbours), 3) self.assertTrue(block1 in neighbours) self.assertTrue(block3 in neighbours) self.assertTrue(block4 in neighbours) neighbours = block3.getNeighbours() self.assertEqual(len(neighbours), 1) self.assertTrue(block2 in neighbours) neighbours = block4.getNeighbours() self.assertEqual(len(neighbours), 2) self.assertTrue(block1 in neighbours) self.assertTrue(block2 in neighbours) neighbours = block5.getNeighbours() self.assertEqual(len(neighbours), 0)
def test_node_pos(self): grid = EclGrid.create_rectangular( (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_neighbours(self): with TestAreaContext("python/fault_block_layer/neighbour") as work_area: with open("kw.grdecl","w") as fileH: fileH.write("FAULTBLK \n") fileH.write("1 1 1 0 0\n") fileH.write("1 2 2 0 3\n") fileH.write("4 2 2 3 3\n") fileH.write("4 4 4 0 0\n") fileH.write("4 4 4 0 5\n") fileH.write("/\n") kw = EclKW.read_grdecl(open("kw.grdecl") , "FAULTBLK" , ecl_type = EclTypeEnum.ECL_INT_TYPE) grid = EclGrid.create_rectangular( (5,5,1) , (1,1,1) ) layer = FaultBlockLayer( grid , 0 ) layer.loadKeyword( kw ) block1 = layer.getBlock( 1 ) block2 = layer.getBlock( 2 ) block3 = layer.getBlock( 3 ) block4 = layer.getBlock( 4 ) block5 = layer.getBlock( 5 ) self.assertEqual( block1.getParentLayer() , layer ) #Expected: 1 -> {2,4}, 2 -> {1,3,4}, 3 -> {2}, 4 -> {1,2}, 5-> {} neighbours = block1.getNeighbours() self.assertEqual( len(neighbours) , 2) self.assertTrue( block2 in neighbours ) self.assertTrue( block4 in neighbours ) neighbours = block2.getNeighbours() self.assertEqual( len(neighbours) , 3) self.assertTrue( block1 in neighbours ) self.assertTrue( block3 in neighbours ) self.assertTrue( block4 in neighbours ) neighbours = block3.getNeighbours() self.assertEqual( len(neighbours) , 1) self.assertTrue( block2 in neighbours ) neighbours = block4.getNeighbours() self.assertEqual( len(neighbours) , 2) self.assertTrue( block1 in neighbours ) self.assertTrue( block2 in neighbours ) neighbours = block5.getNeighbours() self.assertEqual( len(neighbours) , 0)
def test_add_polyline_barrier1(self): grid = EclGrid.create_rectangular( (4,1,1) , (1,1,1) ) layer = FaultBlockLayer( self.grid , 0 ) polyline = Polyline( init_points = [ (1.99 , 0.001) , (2.01 , 0.99)]) points = [((1,0) , (2,0))] geo_layer = layer.getGeoLayer() for p1,p2 in points: self.assertTrue(geo_layer.cellContact( p1 , p2 )) layer.addPolylineBarrier( polyline ) for p1,p2 in points: print(p1,p2) self.assertFalse(geo_layer.cellContact( p1 , p2 ))
def test_EclRegion_properties(self): grid = EclGrid.create_rectangular( (10,10,10) , (1,1,1)) region = EclRegion( grid , False ) with warnings.catch_warnings(): region.active_size with warnings.catch_warnings(): region.global_size with warnings.catch_warnings(): region.global_list with warnings.catch_warnings(): region.active_list
def test_EclRegion_properties(self): grid = EclGrid.create_rectangular((10, 10, 10), (1, 1, 1)) region = EclRegion(grid, False) with warnings.catch_warnings(): region.active_size with warnings.catch_warnings(): region.global_size with warnings.catch_warnings(): region.global_list with warnings.catch_warnings(): region.active_list
def test_fault_block(self): grid = EclGrid.create_rectangular( (5,5,1) , (1,1,1) ) kw = EclKW.create( "FAULTBLK" , grid.size , EclTypeEnum.ECL_INT_TYPE ) kw.assign( 0 ) for j in range(1,4): for i in range(1,4): g = i + j*grid.getNX() kw[g] = 1 layer = FaultBlockLayer( grid , 0 ) layer.scanKeyword( kw ) block = layer[1] self.assertEqual( (2.50 , 2.50) , block.getCentroid() ) self.assertEqual( len(block) , 9) self.assertEqual( layer , block.getParentLayer() )
def test_faultLine_center(self): nx = 10 ny = 10 nz = 2 grid = EclGrid.create_rectangular( (nx,ny,nz) , (0.1,0.1,0.1)) fl = FaultLine(grid , 0) C1 = (nx + 1) * 5 + 3 C2 = C1 + 2 C3 = C2 + 2 s1 = FaultSegment( C1 , C2 ) s2 = FaultSegment( C2 , C3 ) fl.tryAppend( s1 ) fl.tryAppend( s2 ) self.assertEqual( len(fl) , 2 ) self.assertEqual( fl.center() , (0.50 , 0.50) )
def test_num_linesegment(self): nx = 10 ny = 10 nz = 1 grid = EclGrid.create_rectangular((nx, ny, nz), (1, 1, 1)) with TestAreaContext("python/faults/line_order"): with open("faults.grdecl", "w") as f: f.write("""FAULTS \'F1\' 1 4 2 2 1 1 \'Y\' / \'F1\' 6 8 2 2 1 1 \'Y\' / \'F2\' 1 8 2 2 1 1 \'Y\' / / """) faults = FaultCollection(grid, "faults.grdecl") f1 = faults["F1"] f2 = faults["F2"] self.assertEqual(2, f1.numLines(0)) self.assertEqual(1, f2.numLines(0))
def test_num_linesegment(self): nx = 10 ny = 10 nz = 1 grid = EclGrid.create_rectangular( (nx , ny , nz) , (1,1,1) ) with TestAreaContext("python/faults/line_order"): with open("faults.grdecl" , "w") as f: f.write("""FAULTS \'F1\' 1 4 2 2 1 1 \'Y\' / \'F1\' 6 8 2 2 1 1 \'Y\' / \'F2\' 1 8 2 2 1 1 \'Y\' / / """) with open("faults.grdecl") as f: faults = FaultCollection( grid , "faults.grdecl" ) f1 = faults["F1"] f2 = faults["F2"] self.assertEqual( 2 , f1.numLines(0)) self.assertEqual( 1 , f2.numLines(0))
def setUp(self): self.grid = EclGrid.create_rectangular( (16,16,1) , (1,1,1) ) self.poly1 = Polyline(init_points = [(0,0) , (0,4) , (5,5) , (0,5)]) self.poly2 = Polyline(init_points = [(11,11) , (16,12) , (16,16) , (12,16)]) self.fault_block_kw = EclKW.create( "FAULTBLK" , self.grid.getGlobalSize() , EclTypeEnum.ECL_INT_TYPE ) self.fault_block_kw.assign( 0 ) self.faults = FaultCollection( self.grid ) for j in range(4): for i in range(4): g1 = i + j*self.grid.getNX() g2 = i + 12 + (j + 12)* self.grid.getNX() self.fault_block_kw[g1] = 1 self.fault_block_kw[g2] = 2 self.fault_blocks = [] for k in range(self.grid.getNZ()): block = FaultBlockLayer( self.grid , k) block.scanKeyword( self.fault_block_kw ) self.fault_blocks.append( block )
def test_stepped(self): grid = EclGrid.create_rectangular((6, 1, 4), (1, 1, 1)) f = Fault(grid, "F") f.addRecord(4, 4, 0, 0, 0, 1, "X") f.addRecord(2, 2, 0, 0, 1, 1, "Z") f.addRecord(1, 1, 0, 0, 2, 3, "X") block_kw = EclKW.create("FAULTBLK", grid.getGlobalSize(), EclTypeEnum.ECL_INT_TYPE) block_kw.assign(1) block_kw[5] = 2 block_kw[11] = 2 block_kw[14:18] = 2 block_kw[14:18] = 2 block_kw[20:23] = 2 layer0 = FaultBlockLayer(grid, 0) layer0.scanKeyword(block_kw) layer0.addFaultBarrier(f) self.assertTrue(layer0.cellContact((0, 0), (1, 0))) self.assertFalse(layer0.cellContact((4, 0), (5, 0))) layer1 = FaultBlockLayer(grid, 1) layer1.scanKeyword(block_kw) layer1.addFaultBarrier(f) self.assertTrue(layer1.cellContact((0, 0), (1, 0))) self.assertFalse(layer1.cellContact((4, 0), (5, 0))) layer2 = FaultBlockLayer(grid, 2) layer2.scanKeyword(block_kw) layer2.addFaultBarrier(f) self.assertTrue(layer2.cellContact((0, 0), (1, 0))) self.assertFalse(layer2.cellContact((1, 0), (2, 0))) layer3 = FaultBlockLayer(grid, 3) layer3.scanKeyword(block_kw) layer3.addFaultBarrier(f) self.assertTrue(layer3.cellContact((0, 0), (1, 0))) self.assertFalse(layer3.cellContact((1, 0), (2, 0)))
def test_fault_line_order(self): nx = 120 ny = 60 nz = 43 grid = EclGrid.create_rectangular((nx, ny, nz), (1, 1, 1)) with TestAreaContext("python/faults/line_order"): with open("faults.grdecl", "w") as f: f.write("""FAULTS \'F\' 105 107 50 50 1 43 \'Y\' / \'F\' 108 108 50 50 1 43 \'X\' / \'F\' 108 108 50 50 22 43 \'Y\' / \'F\' 109 109 49 49 1 43 \'Y\' / \'F\' 110 110 49 49 1 43 \'X\' / \'F\' 111 111 48 48 1 43 \'Y\' / / """) faults = FaultCollection(grid, "faults.grdecl") fault = faults["F"] layer = fault[29] self.assertEqual(len(layer), 2) line1 = layer[0] line2 = layer[1] self.assertEqual(len(line1), 4) self.assertEqual(len(line2), 2) seg0 = line1[0] seg1 = line1[1] seg2 = line1[2] seg3 = line1[3] self.assertEqual(seg0.getCorners(), (50 * (nx + 1) + 104, 50 * (nx + 1) + 107)) self.assertEqual(seg1.getCorners(), (50 * (nx + 1) + 107, 50 * (nx + 1) + 108)) self.assertEqual(seg2.getCorners(), (50 * (nx + 1) + 108, 49 * (nx + 1) + 108)) self.assertEqual(seg3.getCorners(), (49 * (nx + 1) + 108, 49 * (nx + 1) + 109))
def test_stepped(self): grid = EclGrid.create_rectangular( (6,1,4) , (1,1,1)) f = Fault(grid , "F") f.addRecord(4,4,0,0,0,1,"X") f.addRecord(2,2,0,0,1,1,"Z") f.addRecord(1,1,0,0,2,3,"X") block_kw = EclKW.create("FAULTBLK" , grid.getGlobalSize() , EclTypeEnum.ECL_INT_TYPE) block_kw.assign(1) block_kw[5] = 2 block_kw[11] = 2 block_kw[14:18] = 2 block_kw[14:18] = 2 block_kw[20:23] = 2 layer0 = FaultBlockLayer( grid , 0 ) layer0.scanKeyword( block_kw ) layer0.addFaultBarrier( f ) self.assertTrue( layer0.cellContact((0,0) , (1,0))) self.assertFalse( layer0.cellContact((4,0) , (5,0))) layer1 = FaultBlockLayer( grid , 1 ) layer1.scanKeyword( block_kw ) layer1.addFaultBarrier( f ) self.assertTrue( layer1.cellContact((0,0) , (1,0))) self.assertFalse( layer1.cellContact((4,0) , (5,0))) layer2 = FaultBlockLayer( grid , 2 ) layer2.scanKeyword( block_kw ) layer2.addFaultBarrier( f ) self.assertTrue( layer2.cellContact((0,0) , (1,0))) self.assertFalse( layer2.cellContact((1,0) , (2,0))) layer3 = FaultBlockLayer( grid , 3 ) layer3.scanKeyword( block_kw ) layer3.addFaultBarrier( f ) self.assertTrue( layer3.cellContact((0,0) , (1,0))) self.assertFalse( layer3.cellContact((1,0) , (2,0)))
def setUp(self): self.grid = EclGrid.create_rectangular((16, 16, 1), (1, 1, 1)) self.poly1 = Polyline(init_points=[(0, 0), (0, 4), (5, 5), (0, 5)]) self.poly2 = Polyline(init_points=[(11, 11), (16, 12), (16, 16), (12, 16)]) self.fault_block_kw = EclKW.create("FAULTBLK", self.grid.getGlobalSize(), EclTypeEnum.ECL_INT_TYPE) self.fault_block_kw.assign(0) self.faults = FaultCollection(self.grid) for j in range(4): for i in range(4): g1 = i + j * self.grid.getNX() g2 = i + 12 + (j + 12) * self.grid.getNX() self.fault_block_kw[g1] = 1 self.fault_block_kw[g2] = 2 self.fault_blocks = [] for k in range(self.grid.getNZ()): block = FaultBlockLayer(self.grid, k) block.scanKeyword(self.fault_block_kw) self.fault_blocks.append(block)
def test_fault_line_order(self): nx = 120 ny = 60 nz = 43 grid = EclGrid.create_rectangular((nx, ny, nz), (1, 1, 1)) with TestAreaContext("python/faults/line_order"): with open("faults.grdecl", "w") as f: f.write( """FAULTS \'F\' 105 107 50 50 1 43 \'Y\' / \'F\' 108 108 50 50 1 43 \'X\' / \'F\' 108 108 50 50 22 43 \'Y\' / \'F\' 109 109 49 49 1 43 \'Y\' / \'F\' 110 110 49 49 1 43 \'X\' / \'F\' 111 111 48 48 1 43 \'Y\' / / """ ) faults = FaultCollection(grid, "faults.grdecl") fault = faults["F"] layer = fault[29] self.assertEqual(len(layer), 2) line1 = layer[0] line2 = layer[1] self.assertEqual(len(line1), 4) self.assertEqual(len(line2), 2) seg0 = line1[0] seg1 = line1[1] seg2 = line1[2] seg3 = line1[3] self.assertEqual(seg0.getCorners(), (50 * (nx + 1) + 104, 50 * (nx + 1) + 107)) self.assertEqual(seg1.getCorners(), (50 * (nx + 1) + 107, 50 * (nx + 1) + 108)) self.assertEqual(seg2.getCorners(), (50 * (nx + 1) + 108, 49 * (nx + 1) + 108)) self.assertEqual(seg3.getCorners(), (49 * (nx + 1) + 108, 49 * (nx + 1) + 109))
def test_add_polyline_barrier2(self): grid = EclGrid.create_rectangular( (10,10,1) , (1,1,1) ) layer = FaultBlockLayer( self.grid , 0 ) polyline = Polyline( init_points = [ (0.1 , 0.9) , (8.9,0.9) , (8.9,8.9) ]) points = [((0,0) , (0,1)), ((2,0) , (2,1)), ((4,0) , (4,1)), ((6,0) , (6,1)), ((8,0) , (8,1)), # ((8,1) , (9,1)), ((8,3) , (9,3)), ((8,5) , (9,5)), ((8,7) , (9,7))] geo_layer = layer.getGeoLayer() for p1,p2 in points: self.assertTrue(geo_layer.cellContact( p1 , p2 )) layer.addPolylineBarrier( polyline ) for p1,p2 in points: print(p1,p2) self.assertFalse(geo_layer.cellContact( p1 , p2 ))
def setUp(self): self.faults1 = self.createTestPath("local/ECLIPSE/FAULTS/fault1.grdecl") self.faults2 = self.createTestPath("local/ECLIPSE/FAULTS/fault2.grdecl") self.grid = EclGrid.create_rectangular( (151,100,50) , (1,1,1))
def test_EclGrid_dims_property(self): with self.assertRaises(DeprecationWarning): grid = EclGrid.create_rectangular( (10,20,30) , (1,1,1) )
def setUpClass(cls): cls.grid = EclGrid.create_rectangular((151, 100, 50), (1, 1, 1))
def test_EclGrid_dims_property(self): with warnings.catch_warnings(): grid = EclGrid.create_rectangular( (10,20,30) , (1,1,1) )
def test_EclGrid_dims_property(self): with self.assertRaises(DeprecationWarning): grid = EclGrid.create_rectangular( (10,20,30) , (1,1,1) )
def test_dims(self): grid = EclGrid.create_rectangular( (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 )
def test_neighbour_cells(self): nx = 10 ny = 8 nz = 7 grid = EclGrid.create_rectangular( (nx , ny , nz) , (1,1,1) ) faults_file = self.createTestPath("local/ECLIPSE/FAULTS/faults_nb.grdecl") faults = FaultCollection( grid , faults_file ) fault = faults["FY"] self.assertEqual(len(fault),1) fault_layer = fault[0] fl1 = fault_layer[0] nb_cells1 = fl1.getNeighborCells() true_nb_cells1 = [(0, nx) , (1,nx + 1), (2,nx+2) , (3,nx + 3) , (4,nx+4)] self.assertListEqual( nb_cells1 , true_nb_cells1 ) fl2 = fault_layer[1] nb_cells2 = fl2.getNeighborCells() true_nb_cells2 = [(6, nx+6) , (7,nx + 7), (8 , nx+8) , (9,nx + 9)] self.assertListEqual( nb_cells2 , true_nb_cells2 ) nb_cells = fault_layer.getNeighborCells() self.assertListEqual( nb_cells , true_nb_cells1 + true_nb_cells2) fault = faults["FY0"] fault_layer = fault[0] fl1 = fault_layer[0] nb_cells1 = fl1.getNeighborCells() true_nb_cells1 = [(-1,0) , (-1,1), (-1,2)] self.assertListEqual( nb_cells1 , true_nb_cells1 ) fault = faults["FYNY"] fault_layer = fault[0] fl1 = fault_layer[0] nb_cells1 = fl1.getNeighborCells() true_nb_cells1 = [(nx * (ny - 1) , -1), (nx * (ny - 1) + 1 , -1), (nx * (ny - 1) + 2, -1)] self.assertListEqual( nb_cells1 , true_nb_cells1 ) fault = faults["FX"] fault_layer = fault[0] fl1 = fault_layer[0] nb_cells1 = fl1.getNeighborCells() true_nb_cells1 = [(0,1) , (nx , nx+1) , (2*nx , 2*nx + 1)] self.assertListEqual( nb_cells1 , true_nb_cells1 ) fault = faults["FX0"] fault_layer = fault[0] fl1 = fault_layer[0] nb_cells1 = fl1.getNeighborCells() true_nb_cells1 = [(-1 , 0) , (-1 , nx) , (-1 , 2*nx)] self.assertListEqual( nb_cells1 , true_nb_cells1 ) fault = faults["FXNX"] fault_layer = fault[0] fl1 = fault_layer[0] nb_cells1 = fl1.getNeighborCells() true_nb_cells1 = [(nx -1 , -1) , (2*nx -1 , -1) , (3*nx - 1 , -1)] self.assertListEqual( nb_cells1 , true_nb_cells1 )
def test_EclGrid_get_corner_xyz(self): grid = EclGrid.create_rectangular((10, 20, 30), (1, 1, 1)) with warnings.catch_warnings(): grid.get_corner_xyz(0, global_index=10)