def test_sliced_set(self):
kw = EclKW("REGIONS" , 10 , EclDataType.ECL_INT)
kw.assign(99)
kw[0:5] = 66
self.assertEqual(kw[0] , 66)
self.assertEqual(kw[4] , 66)
self.assertEqual(kw[5] , 99)
def test_numeric_equal(self):
kw1 = EclKW("Name1", 10, EclTypeEnum.ECL_DOUBLE_TYPE)
kw2 = EclKW("Name1", 10, EclTypeEnum.ECL_DOUBLE_TYPE)
shift = 0.0001
value = 1000
abs_diff = shift
rel_diff = shift / (shift + 2 * value)
kw1.assign(value)
kw2.assign(value + shift)
self.assertTrue(
kw1.equal_numeric(kw2,
abs_epsilon=abs_diff * 1.1,
rel_epsilon=rel_diff * 1.1))
self.assertFalse(
kw1.equal_numeric(kw2,
abs_epsilon=abs_diff * 1.1,
rel_epsilon=rel_diff * 0.9))
self.assertFalse(
kw1.equal_numeric(kw2,
abs_epsilon=abs_diff * 0.9,
rel_epsilon=rel_diff * 1.1))
self.assertTrue(
kw1.equal_numeric(kw2, abs_epsilon=0, rel_epsilon=rel_diff * 1.1))
self.assertTrue(
kw1.equal_numeric(kw2, abs_epsilon=abs_diff * 1.1, rel_epsilon=0))
def globalKWCopy(self, kw , default_value):
if len(kw) == self.getGlobalSize( ):
return kw.copy( )
elif len(kw) == self.getNumActive():
kw_copy = EclKW( kw.getName() , self.getGlobalSize() , kw.getEclType())
kw_copy.assign( default_value )
self._global_kw_copy( kw_copy , kw)
return kw_copy
else:
raise ValueError("The input keyword must have nx*n*nz or nactive elements. Size:%d invalid" % len(kw))
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_block_view(self):
with TestAreaContext("python/ecl_file/view"):
with openFortIO("TEST" , mode = FortIO.WRITE_MODE) as f:
for i in range(5):
header = EclKW("HEADER" , 1 , EclTypeEnum.ECL_INT_TYPE )
header[0] = i
data1 = EclKW("DATA1" , 100 , EclTypeEnum.ECL_INT_TYPE )
data1.assign( i )
data2 = EclKW("DATA2" , 100 , EclTypeEnum.ECL_INT_TYPE )
data2.assign( i*10 )
header.fwrite( f )
data1.fwrite( f )
data2.fwrite( f )
ecl_file = EclFile("TEST")
with self.assertRaises(KeyError):
ecl_file.blockView("NO" , 1)
with self.assertRaises(IndexError):
ecl_file.blockView("HEADER" , 100)
for i in range(5):
view = ecl_file.blockView("HEADER" , i)
self.assertEqual( len(view) , 3)
header = view["HEADER"][0]
data1 = view["DATA1"][0]
data2 = view["DATA2"][0]
self.assertEqual( header[0] , i )
self.assertEqual( data1[99] , i )
self.assertEqual( data2[99] , i*10 )
for i in range(5):
view = ecl_file.blockView2("HEADER" , "DATA2", i )
self.assertEqual( len(view) , 2)
header = view["HEADER"][0]
data1 = view["DATA1"][0]
self.assertEqual( header[0] , i )
self.assertEqual( data1[99] , i )
self.assertFalse( "DATA2" in view )
view = ecl_file.blockView2("HEADER" , None, 0 )
self.assertEqual( len(view) , len(ecl_file))
view = ecl_file.blockView2(None , "DATA2", 0 )
def globalKWCopy(self, kw, default_value):
if len(kw) == self.getGlobalSize():
return kw.copy()
elif len(kw) == self.getNumActive():
kw_copy = EclKW(kw.getName(), self.getGlobalSize(), kw.data_type)
kw_copy.assign(default_value)
self._global_kw_copy(kw_copy, kw)
return kw_copy
else:
raise ValueError(
"The input keyword must have nx*n*nz or nactive elements. Size:%d invalid"
% len(kw))
def test_block_view(self):
with TestAreaContext("python/ecl_file/view"):
with openFortIO("TEST", mode=FortIO.WRITE_MODE) as f:
for i in range(5):
header = EclKW("HEADER", 1, EclTypeEnum.ECL_INT_TYPE)
header[0] = i
data1 = EclKW("DATA1", 100, EclTypeEnum.ECL_INT_TYPE)
data1.assign(i)
data2 = EclKW("DATA2", 100, EclTypeEnum.ECL_INT_TYPE)
data2.assign(i * 10)
header.fwrite(f)
data1.fwrite(f)
data2.fwrite(f)
ecl_file = EclFile("TEST")
with self.assertRaises(KeyError):
ecl_file.blockView("NO", 1)
with self.assertRaises(IndexError):
ecl_file.blockView("HEADER", 100)
for i in range(5):
view = ecl_file.blockView("HEADER", i)
self.assertEqual(len(view), 3)
header = view["HEADER"][0]
data1 = view["DATA1"][0]
data2 = view["DATA2"][0]
self.assertEqual(header[0], i)
self.assertEqual(data1[99], i)
self.assertEqual(data2[99], i * 10)
for i in range(5):
view = ecl_file.blockView2("HEADER", "DATA2", i)
self.assertEqual(len(view), 2)
header = view["HEADER"][0]
data1 = view["DATA1"][0]
self.assertEqual(header[0], i)
self.assertEqual(data1[99], i)
self.assertFalse("DATA2" in view)
view = ecl_file.blockView2("HEADER", None, 0)
self.assertEqual(len(view), len(ecl_file))
view = ecl_file.blockView2(None, "DATA2", 0)
def test_mul(self):
kw1 = EclKW("Name1", 10, EclTypeEnum.ECL_INT_TYPE)
kw1.assign(10)
kw2 = EclKW("Name1", 10, EclTypeEnum.ECL_INT_TYPE)
kw2.assign(2)
kw3 = kw1 * kw2
kw4 = kw1 + kw2
self.assertEqual(len(kw3), len(kw1))
self.assertEqual(len(kw4), len(kw1))
for v in kw3:
self.assertEqual(v, 20)
for v in kw4:
self.assertEqual(v, 12)
def test_mul(self):
kw1 = EclKW("Name1" , 10 , EclTypeEnum.ECL_INT_TYPE )
kw1.assign( 10 )
kw2 = EclKW("Name1" , 10 , EclTypeEnum.ECL_INT_TYPE )
kw2.assign( 2 )
kw3 = kw1 * kw2
kw4 = kw1 + kw2
self.assertEqual( len(kw3) , len(kw1))
self.assertEqual( len(kw4) , len(kw1))
for v in kw3:
self.assertEqual( v , 20 )
for v in kw4:
self.assertEqual( v , 12 )
def test_fault_block(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 )
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_numeric_equal(self):
kw1 = EclKW("Name1" , 10 , EclTypeEnum.ECL_DOUBLE_TYPE )
kw2 = EclKW("Name1" , 10 , EclTypeEnum.ECL_DOUBLE_TYPE )
shift = 0.0001
value = 1000
abs_diff = shift
rel_diff = shift / (shift + 2* value)
kw1.assign( value )
kw2.assign( value + shift )
self.assertTrue( kw1.equal_numeric( kw2 , abs_epsilon = abs_diff * 1.1 , rel_epsilon = rel_diff * 1.1))
self.assertFalse( kw1.equal_numeric( kw2 , abs_epsilon = abs_diff * 1.1 , rel_epsilon = rel_diff * 0.9))
self.assertFalse( kw1.equal_numeric( kw2 , abs_epsilon = abs_diff * 0.9 , rel_epsilon = rel_diff * 1.1))
self.assertTrue( kw1.equal_numeric( kw2 , abs_epsilon = 0 , rel_epsilon = rel_diff * 1.1))
self.assertTrue( kw1.equal_numeric( kw2 , abs_epsilon = abs_diff * 1.1 , rel_epsilon = 0))
def test_first_different(self):
kw1 = EclKW( "NAME1" , 100 , EclTypeEnum.ECL_INT_TYPE)
kw2 = EclKW( "NAME2" , 100 , EclTypeEnum.ECL_INT_TYPE)
kw3 = EclKW( "NAME2" , 200 , EclTypeEnum.ECL_INT_TYPE)
kw4 = EclKW( "NAME2" , 100 , EclTypeEnum.ECL_FLOAT_TYPE)
kw5 = EclKW( "NAME2" , 100 , EclTypeEnum.ECL_FLOAT_TYPE)
with self.assertRaises( IndexError ):
EclKW.firstDifferent( kw1 , kw2 , offset = 100 )
with self.assertRaises( ValueError ):
EclKW.firstDifferent( kw1 , kw3 )
with self.assertRaises( TypeError ):
EclKW.firstDifferent( kw1 , kw4 )
with self.assertRaises( IndexError ):
kw1.firstDifferent( kw2 , offset = 100 )
with self.assertRaises( ValueError ):
kw1.firstDifferent( kw3 )
with self.assertRaises( TypeError ):
kw1.firstDifferent( kw4 )
kw1.assign( 1 )
kw2.assign( 1 )
self.assertEqual( kw1.firstDifferent( kw2 ) , len(kw1))
kw1[0] = 100
self.assertEqual( kw1.firstDifferent( kw2 ) , 0)
self.assertEqual( kw1.firstDifferent( kw2 , offset = 1) , len(kw1))
kw1[10] = 100
self.assertEqual( kw1.firstDifferent( kw2 , offset = 1) , 10)
kw4.assign( 1.0 )
kw5.assign( 1.0 )
self.assertEqual( kw4.firstDifferent( kw5 ) , len(kw4))
kw4[10] *= 1.0001
self.assertEqual( kw4.firstDifferent( kw5 ) , 10)
self.assertEqual( kw4.firstDifferent( kw5 , epsilon = 1.0) , len(kw4))
self.assertEqual( kw4.firstDifferent( kw5 , epsilon = 0.0000001) , 10)
def test_first_different(self):
kw1 = EclKW( "NAME1" , 100 , EclDataType.ECL_INT)
kw2 = EclKW( "NAME2" , 100 , EclDataType.ECL_INT)
kw3 = EclKW( "NAME2" , 200 , EclDataType.ECL_INT)
kw4 = EclKW( "NAME2" , 100 , EclDataType.ECL_FLOAT)
kw5 = EclKW( "NAME2" , 100 , EclDataType.ECL_FLOAT)
with self.assertRaises( IndexError ):
EclKW.firstDifferent( kw1 , kw2 , offset = 100 )
with self.assertRaises( ValueError ):
EclKW.firstDifferent( kw1 , kw3 )
with self.assertRaises( TypeError ):
EclKW.firstDifferent( kw1 , kw4 )
with self.assertRaises( IndexError ):
kw1.firstDifferent( kw2 , offset = 100 )
with self.assertRaises( ValueError ):
kw1.firstDifferent( kw3 )
with self.assertRaises( TypeError ):
kw1.firstDifferent( kw4 )
kw1.assign( 1 )
kw2.assign( 1 )
self.assertEqual( kw1.firstDifferent( kw2 ) , len(kw1))
kw1[0] = 100
self.assertEqual( kw1.firstDifferent( kw2 ) , 0)
self.assertEqual( kw1.firstDifferent( kw2 , offset = 1) , len(kw1))
kw1[10] = 100
self.assertEqual( kw1.firstDifferent( kw2 , offset = 1) , 10)
kw4.assign( 1.0 )
kw5.assign( 1.0 )
self.assertEqual( kw4.firstDifferent( kw5 ) , len(kw4))
kw4[10] *= 1.0001
self.assertEqual( kw4.firstDifferent( kw5 ) , 10)
self.assertEqual( kw4.firstDifferent( kw5 , epsilon = 1.0) , len(kw4))
self.assertEqual( kw4.firstDifferent( kw5 , epsilon = 0.0000001) , 10)
def test_stepped(self):
grid = EclGrid.createRectangular( (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("FAULTBLK" , grid.getGlobalSize() , EclDataType.ECL_INT)
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_stepped(self):
grid = EclGrid.createRectangular((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("FAULTBLK", grid.getGlobalSize(), EclDataType.ECL_INT)
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)))
class FaultBlockTest(ExtendedTestCase):
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_fault_block(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 )
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_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_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 test_neighbours2(self):
nx = 8
ny = 8
nz = 1
grid = EclGrid.createRectangular( (nx , ny , nz) , (1,1,1) )
layer = FaultBlockLayer( grid , 0 )
with TestAreaContext("python/FaultBlocks/neighbours"):
with open("faultblock.grdecl","w") as fileH:
fileH.write("FAULTBLK \n")
fileH.write("1 1 1 1 2 2 2 2 \n")
fileH.write("1 1 1 1 2 2 2 2 \n")
fileH.write("1 1 1 1 2 2 2 2 \n")
fileH.write("1 1 1 1 2 2 2 2 \n")
fileH.write("3 3 3 3 2 2 2 2 \n")
fileH.write("3 3 3 3 2 2 2 2 \n")
fileH.write("3 3 3 3 2 2 2 2 \n")
fileH.write("3 3 3 3 2 2 2 2 \n")
fileH.write("/\n")
kw = EclKW.read_grdecl(open("faultblock.grdecl") , "FAULTBLK" , ecl_type = EclDataType.ECL_INT)
with open("faults.grdecl" , "w") as f:
f.write("FAULTS\n")
f.write("\'FY\' 1 4 4 4 1 1 'Y' /\n")
f.write("\'FX\' 4 4 1 8 1 1 'X' /\n")
f.write("/")
faults = FaultCollection( grid , "faults.grdecl")
layer.loadKeyword( kw )
b1 = layer.getBlock( 1 )
b2 = layer.getBlock( 2 )
b3 = layer.getBlock( 3 )
nb = b1.getNeighbours()
self.assertTrue( b2 in nb )
self.assertTrue( b3 in nb )
polylines1 = CPolylineCollection()
p1 = polylines1.createPolyline(name="P1")
p1.addPoint(4,0)
p1.addPoint(4,4)
p1.addPoint(4,8)
nb = b1.getNeighbours( polylines = polylines1 )
self.assertFalse( b2 in nb )
self.assertTrue( b3 in nb )
polylines2 = CPolylineCollection()
p1 = polylines2.createPolyline(name="P2")
p1.addPoint(0,4)
p1.addPoint(4,4)
nb = b1.getNeighbours( polylines = polylines2 )
self.assertTrue( b2 in nb )
self.assertFalse( b3 in nb )
layer.addFaultBarrier( faults["FY"] )
nb = b1.getNeighbours()
self.assertTrue( b2 in nb )
self.assertFalse( b3 in nb )
layer.addFaultBarrier( faults["FX"] )
nb = b1.getNeighbours()
self.assertEqual( len(nb) , 0 )
def test_neighbours3(self):
nx = 8
ny = 8
nz = 1
grid = EclGrid.createRectangular( (nx , ny , nz) , (1,1,1) )
layer = FaultBlockLayer( grid , 0 )
with TestAreaContext("python/FaultBlocks/neighbours"):
with open("faultblock.grdecl","w") as fileH:
fileH.write("FAULTBLK \n")
fileH.write("1 1 1 1 2 2 2 2 \n")
fileH.write("1 1 1 1 2 2 2 2 \n")
fileH.write("1 1 1 1 2 2 2 2 \n")
fileH.write("1 1 1 1 2 2 2 2 \n")
fileH.write("1 1 1 1 1 2 2 2 \n")
fileH.write("1 1 1 1 1 2 2 2 \n")
fileH.write("1 1 1 1 1 2 2 2 \n")
fileH.write("1 1 1 1 1 2 2 2 \n")
fileH.write("/\n")
kw = EclKW.read_grdecl(open("faultblock.grdecl") , "FAULTBLK" , ecl_type = EclDataType.ECL_INT)
with open("faults.grdecl" , "w") as f:
f.write("FAULTS\n")
f.write("\'FX\' 4 4 1 4 1 1 'X' /\n")
f.write("\'FX\' 5 5 5 8 1 1 'X' /\n")
f.write("/")
faults = FaultCollection( grid , "faults.grdecl")
layer.loadKeyword( kw )
b1 = layer.getBlock( 1 )
b2 = layer.getBlock( 2 )
nb = b1.getNeighbours()
self.assertTrue( b2 in nb )
layer.addFaultBarrier( faults["FX"] , link_segments = False)
nb = b1.getNeighbours()
self.assertTrue( b2 in nb )
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 )
#with self.assertRaises:
# layer.getEdgePolygon( )
def test_fault_block_layer(self):
with self.assertRaises(ValueError):
layer = FaultBlockLayer( self.grid , -1 )
with self.assertRaises(ValueError):
layer = FaultBlockLayer( self.grid , self.grid.getGlobalSize() )
layer = FaultBlockLayer( self.grid , 1 )
self.assertEqual( 1 , layer.getK() )
kw = EclKW( "FAULTBLK" , self.grid.getGlobalSize() , EclDataType.ECL_FLOAT )
with self.assertRaises(ValueError):
layer.scanKeyword( kw )
layer.scanKeyword( self.kw )
self.assertEqual( 2 , len(layer) )
with self.assertRaises(TypeError):
ls = layer["JJ"]
l = []
for blk in layer:
l.append( blk )
self.assertEqual( len(l) , 2 )
l0 = layer[0]
l1 = layer[1]
self.assertTrue( isinstance(l1 , FaultBlock ))
l0.getCentroid()
l1.getBlockID()
with self.assertRaises(IndexError):
l2 = layer[2]
self.assertEqual( True , 1 in layer)
self.assertEqual( True , 2 in layer)
self.assertEqual( False , 77 in layer)
self.assertEqual( False , 177 in layer)
l1 = layer.getBlock( 1 )
self.assertTrue( isinstance(l1 , FaultBlock ))
with self.assertRaises(KeyError):
l =layer.getBlock(66)
with self.assertRaises(KeyError):
layer.deleteBlock(66)
layer.deleteBlock(2)
self.assertEqual( 1 , len(layer))
blk = layer[0]
self.assertEqual( blk.getBlockID() , 1 )
with self.assertRaises(KeyError):
layer.addBlock(1)
blk2 = layer.addBlock(2)
self.assertEqual( len(layer) , 2 )
blk3 = layer.addBlock()
self.assertEqual( len(layer) , 3 )
layer.addBlock(100)
layer.addBlock(101)
layer.addBlock(102)
layer.addBlock(103)
layer.deleteBlock(2)
blk1 = layer.getBlock( 103 )
blk2 = layer[-1]
self.assertEqual( blk1.getBlockID() , blk2.getBlockID() )
fault_block = layer[0]
fault_block.assignToRegion( 2 )
self.assertEqual( [2] , list(fault_block.getRegionList()))
fault_block.assignToRegion( 2 )
self.assertEqual( [2] , list(fault_block.getRegionList()))
fault_block.assignToRegion( 3 )
self.assertEqual( [2,3] , list(fault_block.getRegionList()))
fault_block.assignToRegion( 1 )
self.assertEqual( [1,2,3] , list(fault_block.getRegionList()))
fault_block.assignToRegion( 2 )
self.assertEqual( [1,2,3] , list(fault_block.getRegionList()))
def test_add_polyline_barrier1(self):
grid = EclGrid.createRectangular( (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_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_fault_block_layer_export(self):
layer = FaultBlockLayer( self.grid , 1 )
kw1 = EclKW( "FAULTBLK" , self.grid.getGlobalSize() + 1 , EclDataType.ECL_INT )
with self.assertRaises(ValueError):
layer.exportKeyword( kw1 )
kw2 = EclKW( "FAULTBLK" , self.grid.getGlobalSize() , EclDataType.ECL_FLOAT )
with self.assertRaises(TypeError):
layer.exportKeyword(kw2)
def test_internal_blocks(self):
nx = 8
ny = 8
nz = 1
grid = EclGrid.createRectangular( (nx , ny , nz) , (1,1,1) )
layer = FaultBlockLayer( grid , 0 )
with TestAreaContext("python/FaultBlocks/internal_blocks"):
with open("faultblock.grdecl","w") as fileH:
fileH.write("FAULTBLK \n")
fileH.write("1 1 1 1 2 2 2 2 \n")
fileH.write("1 4 4 1 2 5 5 2 \n")
fileH.write("1 4 4 1 2 5 5 2 \n")
fileH.write("1 1 1 1 2 2 2 2 \n")
fileH.write("1 1 1 1 1 2 2 2 \n")
fileH.write("1 1 3 1 1 2 2 2 \n")
fileH.write("1 1 1 1 1 2 2 2 \n")
fileH.write("1 1 1 1 1 2 2 2 \n")
fileH.write("/\n")
kw = EclKW.read_grdecl(open("faultblock.grdecl") , "FAULTBLK" , ecl_type = EclDataType.ECL_INT)
with open("faults.grdecl" , "w") as f:
f.write("FAULTS\n")
f.write("\'FX\' 4 4 1 4 1 1 'X' /\n")
f.write("\'FX\' 5 5 4 4 1 1 'Y' /\n")
f.write("\'FX\' 5 5 5 8 1 1 'X' /\n")
f.write("/")
faults = FaultCollection( grid , "faults.grdecl")
layer.loadKeyword( kw )
layer.addFaultBarrier( faults["FX"] )
b1 = layer.getBlock( 1 )
b2 = layer.getBlock( 2 )
b3 = layer.getBlock( 3 )
b4 = layer.getBlock( 4 )
b5 = layer.getBlock( 5 )
nb = b1.getNeighbours()
for b in nb:
print('Block:%d' % b.getBlockID())
self.assertTrue( len(nb) == 2 )
self.assertTrue( b3 in nb )
self.assertTrue( b4 in nb )
nb = b2.getNeighbours()
self.assertTrue( len(nb) == 1 )
self.assertTrue( b5 in nb )
