def test_rect(self): with TestAreaContext("python/grid-test/testRect"): a1 = 1.0 a2 = 2.0 a3 = 3.0 grid = EclGrid.createRectangular((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.assertFloatEqual(v, a1 * a2 * a3) z = grid.depth(ijk=(4, 4, 4 )) self.assertFloatEqual(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)))
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 test_boundingBox(self): grid = EclGrid.createRectangular((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))) with self.assertRaises(ValueError): grid.getBoundingBox2D( lower_left = (-1,0) ) with self.assertRaises(ValueError): grid.getBoundingBox2D( lower_left = (6,10) ) bbox = grid.getBoundingBox2D( lower_left = (3,3) ) self.assertEqual( bbox , ((3,3) , (10,3) , (10,10) , (3,10))) with self.assertRaises(ValueError): grid.getBoundingBox2D( lower_left = (3,3) , upper_right = (2,2)) bbox = grid.getBoundingBox2D( lower_left = (3,3) , upper_right = (7,7)) self.assertEqual( bbox , ((3,3) , (7,3) , (7,7) , (3,7)))
def make_grid( ): grid = EclGrid.createRectangular( (nx,ny,nz) , (1,1,1) ) if not os.path.isdir("grid"): os.makedirs("grid") grid.save_EGRID("grid/CASE.EGRID") return grid
def make_grid(): grid = EclGrid.createRectangular((nx, ny, nz), (1, 1, 1)) if not os.path.isdir("grid"): os.makedirs("grid") grid.save_EGRID("grid/CASE.EGRID") return grid
def test_extend_to_polyline(self): grid = EclGrid.createRectangular((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.createRectangular((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_geertsma_kernel(): grid = EclGrid.createRectangular(dims=(1, 1, 1), dV=(50, 50, 50)) with TestAreaContext("Subsidence"): p1 = [1] create_restart(grid, "TEST", p1) create_init(grid, "TEST") init = EclFile("TEST.INIT") restart_file = EclFile("TEST.UNRST") restart_view1 = restart_file.restartView(sim_time=datetime.date(2000, 1, 1)) subsidence = EclSubsidence(grid, init) subsidence.add_survey_PRESSURE("S1", restart_view1) youngs_modulus = 5E8 poisson_ratio = 0.3 seabed = 0 above = 100 topres = 2000 receiver = (1000, 1000, 0) dz = subsidence.evalGeertsma("S1", None, receiver, youngs_modulus, poisson_ratio, seabed) np.testing.assert_almost_equal(dz, 3.944214576168326e-09) receiver = (1000, 1000, topres - seabed - above) dz = subsidence.evalGeertsma("S1", None, receiver, youngs_modulus, poisson_ratio, seabed) np.testing.assert_almost_equal(dz, 5.8160298201497136e-08)
def test_join_faults(self): grid = EclGrid.createRectangular((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_create(self): grid = EclGrid.createRectangular((10, 20, 5), (1, 1, 1)) field_config = FieldConfig("PRESSURE", grid) block_obs = BlockObservation("P-CONFIG", field_config, grid) self.assertEqual(len(block_obs), 0) block_obs.addPoint(1, 2, 3, 100, 25) self.assertEqual(len(block_obs), 1) self.assertEqual(block_obs.getValue(0), 100) self.assertEqual(block_obs.getStd(0), 25) self.assertEqual(block_obs.getStdScaling(0), 1) block_obs.addPoint(1, 2, 4, 200, 50) self.assertEqual(len(block_obs), 2) self.assertEqual(block_obs.getValue(1), 200) self.assertEqual(block_obs.getStd(1), 50) self.assertEqual(block_obs.getStdScaling(1), 1) active_list = ActiveList() block_obs.updateStdScaling(0.50, active_list) self.assertEqual(block_obs.getStdScaling(0), 0.50) self.assertEqual(block_obs.getStdScaling(1), 0.50) active_list.addActiveIndex(1) block_obs.updateStdScaling(2.00, active_list) self.assertEqual(block_obs.getStdScaling(0), 0.50) self.assertEqual(block_obs.getStdScaling(1), 2.00)
def test_cast(self): actnum = IntVector(default_value=1, initial_size=1000) for i in range(100): actnum[i] = 0 grid = EclGrid.createRectangular((10, 10, 10), (1, 1, 1), actnum=actnum) kw_wrong_size = EclKW("KW", 27, EclDataType.ECL_FLOAT) kw_global_size = EclKW("KW", grid.getGlobalSize(), EclDataType.ECL_FLOAT) kw_active_size = EclKW("KW", grid.getNumActive(), EclDataType.ECL_FLOAT) with self.assertRaises(ValueError): Ecl3DKW.castFromKW(kw_wrong_size, grid) Ecl3DKW.castFromKW(kw_global_size, grid) self.assertTrue(isinstance(kw_global_size, Ecl3DKW)) Ecl3DKW.castFromKW(kw_active_size, grid, default_value=66) self.assertTrue(isinstance(kw_active_size, Ecl3DKW)) self.assertEqual(kw_active_size[0, 0, 0], 66) with self.assertRaises(ValueError): kw_active_size[0, 0, 0] = 88
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=EclDataType.ECL_INT) grid = EclGrid.createRectangular((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_extend_polyline_on(self): grid = EclGrid.createRectangular((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_add_polyline_barrier2(self): grid = EclGrid.createRectangular((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_connectWithPolyline(self): grid = EclGrid.createRectangular((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_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_contact(self): grid = EclGrid.createRectangular((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_setitem(self): actnum = IntVector(default_value=1, initial_size=1000) for i in range(100): actnum[i] = 0 grid = EclGrid.createRectangular((10, 10, 10), (1, 1, 1), actnum=actnum) kw = Ecl3DKW("KW", grid, EclDataType.ECL_FLOAT, default_value=77) with self.assertRaises(IndexError): kw[1000] with self.assertRaises(IndexError): kw[0, 10, 100] with self.assertRaises(ValueError): kw[1, 1] with self.assertRaises(ValueError): kw[1, 1, 1, 1] kw.assign(99) self.assertEqual(kw[0, 0, 0], 77) self.assertEqual(kw[0, 0, 1], 99) with self.assertRaises(ValueError): kw[0, 0, 0] = 88 kw[0, 0, 1] = 100 self.assertEqual(kw[0, 0, 1], 100)
def test_fault_line_order(self): nx = 120 ny = 60 nz = 43 grid = EclGrid.createRectangular( (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_contact2(self): nx = 10 ny = 10 layer = Layer(nx, ny) grid = EclGrid.createRectangular((nx, ny, 1), (1, 1, 1)) # Too short with self.assertRaises(ValueError): layer.addIJBarrier([(1, 5)]) # Out of range with self.assertRaises(ValueError): layer.addIJBarrier([(10, 15), (5, 5)]) # Out of range with self.assertRaises(ValueError): layer.addIJBarrier([(7, 7), (-5, 5)]) # Must have either i1 == i2 or j1 == j2 with self.assertRaises(ValueError): layer.addIJBarrier([(7, 8), (6, 5)]) p1 = (0, 4) p2 = (0, 5) self.assertTrue(layer.cellContact(p1, p2)) layer.addIJBarrier([(0, 5), (nx, 5)]) self.assertFalse(layer.cellContact(p1, p2))
def test_geertsma_kernel_2_source_points_2_vintages(): grid = EclGrid.createRectangular(dims=(2, 1, 1), dV=(100, 100, 100)) with TestAreaContext("Subsidence"): p1 = [1, 10] p2 = [10, 20] create_restart(grid, "TEST", p1, p2) create_init(grid, "TEST") init = EclFile("TEST.INIT") restart_file = EclFile("TEST.UNRST") restart_view1 = restart_file.restartView(sim_time=datetime.date(2000, 1, 1)) restart_view2 = restart_file.restartView(sim_time=datetime.date(2010, 1, 1)) subsidence = EclSubsidence(grid, init) subsidence.add_survey_PRESSURE("S1", restart_view1) subsidence.add_survey_PRESSURE("S2", restart_view2) youngs_modulus = 5E8 poisson_ratio = 0.3 seabed = 0 receiver = (1000, 1000, 0) dz1 = subsidence.evalGeertsma("S1", None, receiver, youngs_modulus, poisson_ratio, seabed) np.testing.assert_almost_equal(dz1, 8.65322541521704e-07) dz2 = subsidence.evalGeertsma("S2", None, receiver, youngs_modulus, poisson_ratio, seabed) np.testing.assert_almost_equal(dz2, 2.275556615015282e-06) np.testing.assert_almost_equal(dz1-dz2, -1.4102340734935779e-06) dz = subsidence.evalGeertsma("S1", "S2", receiver, youngs_modulus, poisson_ratio, seabed) np.testing.assert_almost_equal(dz, dz1-dz2)
def test_grdecl_load(self): with self.assertRaises(IOError): grid = EclGrid.loadFromGrdecl("/file/does/not/exists") with TestAreaContext("python/grid-test/grdeclLoad"): with open("grid.grdecl","w") as f: f.write("Hei ...") with self.assertRaises(ValueError): grid = EclGrid.loadFromGrdecl("grid.grdecl") actnum = IntVector(default_value = 1 , initial_size = 1000) actnum[0] = 0 g1 = EclGrid.createRectangular((10,10,10) , (1,1,1) , actnum = actnum ) self.assertEqual( g1.getNumActive() , actnum.elementSum() ) g1.save_EGRID("G.EGRID") with openEclFile("G.EGRID") as f: with open("grid.grdecl" , "w") as f2: f2.write("SPECGRID\n") f2.write(" 10 10 10 \'F\' /\n") coord_kw = f["COORD"][0] coord_kw.write_grdecl( f2 ) zcorn_kw = f["ZCORN"][0] zcorn_kw.write_grdecl( f2 ) actnum_kw = f["ACTNUM"][0] actnum_kw.write_grdecl( f2 ) g2 = EclGrid.loadFromGrdecl("grid.grdecl") self.assertTrue( g1.equal( g2 ))
def test_fault_barrier(self): nx = 120 ny = 60 nz = 43 grid = EclGrid.createRectangular( (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_create( self ): actnum = IntVector(default_value = 1 , initial_size = 1000) for i in range(100): actnum[i] = 0 grid = EclGrid.createRectangular( (10,10,10) , (1,1,1) , actnum = actnum) kw = Ecl3DKW( "KW" , grid , EclDataType.ECL_FLOAT ) self.assertEqual( len(kw) , grid.getNumActive()) self.assertEqual( (10,10,10) , kw.dims() )
def test_add_polyline_barrier(self): d = 10 layer = Layer(d, d) grid = EclGrid.createRectangular((d, d, 1), (1, 1, 1)) pl = CPolyline(init_points=[(0, 0), (d / 2, d / 2), (d, d)]) layer.addPolylineBarrier(pl, grid, 0) for i in range(d): self.assertTrue(layer.bottomBarrier(i, i)) if i < (d - 1): self.assertTrue(layer.leftBarrier(i + 1, i))
def test_fault_block_edge(self): grid = EclGrid.createRectangular((5, 5, 1), (1, 1, 1)) kw = EclKW("FAULTBLK", grid.getGlobalSize(), EclDataType.ECL_INT) 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.createRectangular( (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 test_PolylineIJ(self): nx = 10 ny = 10 nz = 10 grid = EclGrid.createRectangular((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=EclDataType.ECL_INT) grid = EclGrid.createRectangular((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 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_active(self): d = 10 layer = Layer(d, d) with self.assertRaises(ValueError): layer.activeCell(d + 1, d + 2) self.assertTrue(layer.activeCell(1, 2)) grid = EclGrid.createRectangular((d, d + 1, 1), (1, 1, 1)) with self.assertRaises(ValueError): layer.updateActive(grid, 0) grid = EclGrid.createRectangular((d, d, 1), (1, 1, 1)) with self.assertRaises(ValueError): layer.updateActive(grid, 10) actnum = IntVector(initial_size=d * d * 1, default_value=1) actnum[0] = 0 grid = EclGrid.createRectangular((d, d, 1), (1, 1, 1), actnum=actnum) layer.updateActive(grid, 0) self.assertTrue(layer.activeCell(1, 2)) self.assertFalse(layer.activeCell(0, 0))