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)
