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 )