def test_sum(self): kw_string = EclKW.create("STRING", 100, EclTypeEnum.ECL_CHAR_TYPE) with self.assertRaises(ValueError): kw_string.sum() kw_int = EclKW.create("INT", 4, EclTypeEnum.ECL_INT_TYPE) kw_int[0] = 1 kw_int[1] = 2 kw_int[2] = 3 kw_int[3] = 4 self.assertEqual(kw_int.sum(), 10) kw_d = EclKW.create("D", 4, EclTypeEnum.ECL_DOUBLE_TYPE) kw_d[0] = 1 kw_d[1] = 2 kw_d[2] = 3 kw_d[3] = 4 self.assertEqual(kw_d.sum(), 10) kw_f = EclKW.create("F", 4, EclTypeEnum.ECL_FLOAT_TYPE) kw_f[0] = 1 kw_f[1] = 2 kw_f[2] = 3 kw_f[3] = 4 self.assertEqual(kw_f.sum(), 10) kw_b = EclKW.create("F", 4, EclTypeEnum.ECL_BOOL_TYPE) kw_b[0] = False kw_b[1] = True kw_b[2] = False kw_b[3] = True self.assertEqual(kw_b.sum(), 2)
def test_truncate(self): kw1 = EclKW.create("KW1", 2, EclTypeEnum.ECL_INT_TYPE) kw2 = EclKW.create("KW2", 2, EclTypeEnum.ECL_INT_TYPE) kw1[0] = 99 kw1[1] = 77 kw2[0] = 113 kw2[1] = 335 with TestAreaContext("python/fortio/ftruncate") as t: with openFortIO("file" , mode = FortIO.WRITE_MODE) as f: kw1.fwrite(f) pos1 = f.getPosition( ) kw2.fwrite(f) t.sync( ) # Truncate file in read mode; should fail hard. with openFortIO("file") as f: with self.assertRaises(IOError): f.truncate( ) with openFortIO("file" , mode = FortIO.READ_AND_WRITE_MODE) as f: f.seek( pos1 ) f.truncate( ) f = EclFile("file") self.assertEqual( len(f) , 1) kw1_ = f[0] self.assertEqual( kw1 , kw1_)
def test_long_name(self): with self.assertRaises(ValueError): EclKW.create("LONGLONGNAME" , 10 , EclTypeEnum.ECL_INT_TYPE) kw = EclKW.create("REGIONS" , 10 , EclTypeEnum.ECL_INT_TYPE) with self.assertRaises(ValueError): kw.set_name("LONGLONGNAME")
def test_sum( self ): kw_string = EclKW.create( "STRING" , 100 , EclTypeEnum.ECL_CHAR_TYPE ) with self.assertRaises(ValueError): kw_string.sum() kw_int = EclKW.create( "INT" , 4 , EclTypeEnum.ECL_INT_TYPE ) kw_int[0] = 1 kw_int[1] = 2 kw_int[2] = 3 kw_int[3] = 4 self.assertEqual( kw_int.sum() , 10 ) kw_d = EclKW.create( "D" , 4 , EclTypeEnum.ECL_DOUBLE_TYPE ) kw_d[0] = 1 kw_d[1] = 2 kw_d[2] = 3 kw_d[3] = 4 self.assertEqual( kw_d.sum() , 10 ) kw_f = EclKW.create( "F" , 4 , EclTypeEnum.ECL_FLOAT_TYPE ) kw_f[0] = 1 kw_f[1] = 2 kw_f[2] = 3 kw_f[3] = 4 self.assertEqual( kw_f.sum() , 10 ) kw_b = EclKW.create( "F" , 4 , EclTypeEnum.ECL_BOOL_TYPE ) kw_b[0] = False kw_b[1] = True kw_b[2] = False kw_b[3] = True self.assertEqual( kw_b.sum() , 2 )
def test_kw(self): kw1 = EclKW.create("KW1", 2, EclTypeEnum.ECL_INT_TYPE) kw2 = EclKW.create("KW2", 2, EclTypeEnum.ECL_INT_TYPE) kw1[0] = 99 kw1[1] = 77 kw2[0] = 113 kw2[1] = 335 with TestAreaContext("python/fortio/write-kw"): f = FortIO.writer("test", fmt_file=False) kw1.fwrite(f) f.close() f = FortIO.open("test", mode="a") kw2.fwrite(f) f.close() f = FortIO.open("test", fmt_file=False) k1 = EclKW.fread(f) k2 = EclKW.fread(f) f.close() self.assertTrue(k1.equal(kw1)) self.assertTrue(k2.equal(kw2))
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.create("KW", 27, EclTypeEnum.ECL_FLOAT_TYPE) kw_global_size = EclKW.create("KW", grid.getGlobalSize(), EclTypeEnum.ECL_FLOAT_TYPE) kw_active_size = EclKW.create("KW", grid.getNumActive(), EclTypeEnum.ECL_FLOAT_TYPE) 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_long_name(self): with self.assertRaises(ValueError): EclKW.create("LONGLONGNAME", 10, EclTypeEnum.ECL_INT_TYPE) kw = EclKW.create("REGIONS", 10, EclTypeEnum.ECL_INT_TYPE) with self.assertRaises(ValueError): kw.set_name("LONGLONGNAME")
def test_truncate(self): kw1 = EclKW.create("KW1", 2, EclTypeEnum.ECL_INT_TYPE) kw2 = EclKW.create("KW2", 2, EclTypeEnum.ECL_INT_TYPE) kw1[0] = 99 kw1[1] = 77 kw2[0] = 113 kw2[1] = 335 with TestAreaContext("python/fortio/ftruncate"): with openFortIO("file" , mode = FortIO.WRITE_MODE) as f: kw1.fwrite(f) pos1 = f.getPosition( ) kw2.fwrite(f) # Truncate file in read mode; should fail hard. with openFortIO("file") as f: with self.assertRaises(IOError): f.truncate( ) with openFortIO("file" , mode = FortIO.READ_AND_WRITE_MODE) as f: f.seek( pos1 ) f.truncate( ) f = EclFile("file") self.assertEqual( len(f) , 1) kw1_ = f[0] self.assertEqual( kw1 , kw1_)
def test_ecl_file_indexed_read(self): with TestAreaContext("ecl_file_indexed_read") as area: fortio = FortIO("ecl_file_index_test", mode=FortIO.WRITE_MODE) element_count = 100000 ecl_kw_1 = EclKW.create("TEST1", element_count, EclTypeEnum.ECL_INT_TYPE) ecl_kw_2 = EclKW.create("TEST2", element_count, EclTypeEnum.ECL_INT_TYPE) for index in range(element_count): ecl_kw_1[index] = index ecl_kw_2[index] = index + 3 ecl_kw_1.fwrite(fortio) ecl_kw_2.fwrite(fortio) fortio.close() ecl_file = EclFile("ecl_file_index_test") index_map = IntVector() index_map.append(2) index_map.append(3) index_map.append(5) index_map.append(7) index_map.append(11) index_map.append(13) index_map.append(313) index_map.append(1867) index_map.append(5227) index_map.append(7159) index_map.append(12689) index_map.append(18719) index_map.append(32321) index_map.append(37879) index_map.append(54167) index_map.append(77213) index_map.append(88843) index_map.append(99991) char_buffer_1 = ctypes.create_string_buffer( len(index_map) * ctypes.sizeof(ctypes.c_int)) char_buffer_2 = ctypes.create_string_buffer( len(index_map) * ctypes.sizeof(ctypes.c_int)) eclFileIndexedRead(ecl_file, "TEST2", 0, index_map, char_buffer_2) eclFileIndexedRead(ecl_file, "TEST1", 0, index_map, char_buffer_1) int_buffer_1 = ctypes.cast(char_buffer_1, ctypes.POINTER(ctypes.c_int)) int_buffer_2 = ctypes.cast(char_buffer_2, ctypes.POINTER(ctypes.c_int)) for index, index_map_value in enumerate(index_map): self.assertEqual(index_map_value, int_buffer_1[index]) self.assertEqual(index_map_value, int_buffer_2[index] - 3)
def test_fault_block_layer_export(self): layer = FaultBlockLayer( self.grid , 1 ) kw1 = EclKW.create( "FAULTBLK" , self.grid.size + 1 , EclTypeEnum.ECL_INT_TYPE ) with self.assertRaises(ValueError): layer.exportKeyword( kw1 ) kw2 = EclKW.create( "FAULTBLK" , self.grid.size , EclTypeEnum.ECL_FLOAT_TYPE ) with self.assertRaises(TypeError): layer.exportKeyword(kw2)
def test_context( self ): with TestAreaContext("python/ecl_file/context"): kw1 = EclKW.create( "KW1" , 100 , EclTypeEnum.ECL_INT_TYPE) kw2 = EclKW.create( "KW2" , 100 , EclTypeEnum.ECL_INT_TYPE) with openFortIO("TEST" , mode = FortIO.WRITE_MODE) as f: kw1.fwrite( f ) kw2.fwrite( f ) with openEclFile("TEST") as ecl_file: self.assertEqual( len(ecl_file) , 2 ) self.assertTrue( ecl_file.has_kw("KW1")) self.assertTrue( ecl_file.has_kw("KW2"))
def test_ecl_file_indexed_read(self): with TestAreaContext("ecl_file_indexed_read") as area: fortio = FortIO("ecl_file_index_test", mode=FortIO.WRITE_MODE) element_count = 100000 ecl_kw_1 = EclKW.create("TEST1", element_count, EclTypeEnum.ECL_INT_TYPE) ecl_kw_2 = EclKW.create("TEST2", element_count, EclTypeEnum.ECL_INT_TYPE) for index in range(element_count): ecl_kw_1[index] = index ecl_kw_2[index] = index + 3 ecl_kw_1.fwrite(fortio) ecl_kw_2.fwrite(fortio) fortio.close() ecl_file = EclFile("ecl_file_index_test") index_map = IntVector() index_map.append(2) index_map.append(3) index_map.append(5) index_map.append(7) index_map.append(11) index_map.append(13) index_map.append(313) index_map.append(1867) index_map.append(5227) index_map.append(7159) index_map.append(12689) index_map.append(18719) index_map.append(32321) index_map.append(37879) index_map.append(54167) index_map.append(77213) index_map.append(88843) index_map.append(99991) char_buffer_1 = ctypes.create_string_buffer(len(index_map) * ctypes.sizeof(ctypes.c_int)) char_buffer_2 = ctypes.create_string_buffer(len(index_map) * ctypes.sizeof(ctypes.c_int)) eclFileIndexedRead(ecl_file, "TEST2", 0, index_map, char_buffer_2) eclFileIndexedRead(ecl_file, "TEST1", 0, index_map, char_buffer_1) int_buffer_1 = ctypes.cast(char_buffer_1, ctypes.POINTER(ctypes.c_int)) int_buffer_2 = ctypes.cast(char_buffer_2, ctypes.POINTER(ctypes.c_int)) for index, index_map_value in enumerate(index_map): self.assertEqual(index_map_value, int_buffer_1[index]) self.assertEqual(index_map_value, int_buffer_2[index] - 3)
def make_field(rng , grid , iens): permx = EclKW.create( "PERMX" , grid.getGlobalSize( ) , EclTypeEnum.ECL_FLOAT_TYPE) permx.assign( rng.getDouble( ) ) poro = EclKW.create( "PORO" , grid.getGlobalSize( ) , EclTypeEnum.ECL_FLOAT_TYPE) poro.assign( rng.getDouble( ) ) if not os.path.isdir("fields"): os.makedirs("fields") with open("fields/permx%d.grdecl" % iens,"w") as f: permx.write_grdecl( f ) with open("fields/poro%d.grdecl" % iens ,"w") as f: poro.write_grdecl( f )
def test_sliced_set(self): kw = EclKW.create("REGIONS" , 10 , EclTypeEnum.ECL_INT_TYPE) kw.assign(99) kw[0:5] = 66 self.assertEqual(kw[0] , 66) self.assertEqual(kw[4] , 66) self.assertEqual(kw[5] , 99)
def test_sliced_set(self): kw = EclKW.create("REGIONS", 10, EclTypeEnum.ECL_INT_TYPE) kw.assign(99) kw[0:5] = 66 self.assertEqual(kw[0], 66) self.assertEqual(kw[4], 66) self.assertEqual(kw[5], 99)
def test_compressed_copy(self): nx = 10 ny = 10 nz = 10 grid = EclGrid.createRectangular( (nx,ny,nz) , (1,1,1) ) kw1 = EclKW.create("KW" , 1001 , EclTypeEnum.ECL_INT_TYPE ) with self.assertRaises(ValueError): cp = grid.compressedKWCopy( kw1 )
def make_field(rng, grid, iens): permx = EclKW.create("PERMX", grid.getGlobalSize(), EclTypeEnum.ECL_FLOAT_TYPE) permx.assign(rng.getDouble()) poro = EclKW.create("PORO", grid.getGlobalSize(), EclTypeEnum.ECL_FLOAT_TYPE) poro.assign(rng.getDouble()) if not os.path.isdir("fields"): os.makedirs("fields") with open("fields/permx%d.grdecl" % iens, "w") as f: permx.write_grdecl(f) with open("fields/poro%d.grdecl" % iens, "w") as f: poro.write_grdecl(f)
def test_create(self): defRegion = RegionDefinition.create( 5 , self.faults , ["DF4_MC","DF15_MC","DF43_MC","DF25_LC","DF21_C","DF1_C",self.poly_file6, "DF26_MC","DF34_MCS","DF32_MC",self.poly_file5]) region_kw = EclKW.create( "REGIONS" , self.grid.getGlobalSize() , EclTypeEnum.ECL_INT_TYPE ) region_kw.assign( 0 ) for k in range(self.grid.getNZ()): with self.assertRaises(NotImplementedError): block_list = defRegion.findInternalBlocks( self.grid , self.fault_blocks[k] )
def test_abs(self): kw = EclKW.create("NAME" , 10 , EclTypeEnum.ECL_CHAR_TYPE) with self.assertRaises(TypeError): abs_kw = abs(kw) kw = EclKW.create("NAME" , 10 , EclTypeEnum.ECL_BOOL_TYPE) with self.assertRaises(TypeError): abs_kw = abs(kw) kw = EclKW.create("NAME" , 10 , EclTypeEnum.ECL_INT_TYPE) for i in range(len(kw)): kw[i] = -i abs_kw = abs(kw) for i in range(len(kw)): self.assertEqual(kw[i] , -i ) self.assertEqual(abs_kw[i] , i )
def test_compressed_copy(self): nx = 10 ny = 10 nz = 10 grid = EclGrid.createRectangular((nx, ny, nz), (1, 1, 1)) kw1 = EclKW.create("KW", 1001, EclTypeEnum.ECL_INT_TYPE) with self.assertRaises(ValueError): cp = grid.compressedKWCopy(kw1)
def compressedKWCopy(self, kw): if len(kw) == self.getNumActive(): return EclKW.copy( kw ) elif len(kw) == self.getGlobalSize(): kw_copy = EclKW.create( kw.getName() , self.getNumActive() , kw.getEclType()) cfunc.compressed_kw_copy( self , 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.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_is_fortran_file(self): with TestAreaContext("python/fortio/guess"): kw1 = EclKW.create("KW" , 12345 , EclTypeEnum.ECL_FLOAT_TYPE) with openFortIO("fortran_file" , mode = FortIO.WRITE_MODE) as f: kw1.fwrite( f ) with open("text_file" , "w") as f: kw1.write_grdecl( f ) self.assertTrue( FortIO.isFortranFile( "fortran_file" )) self.assertFalse( FortIO.isFortranFile( "text_file" ))
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_ecl_kw_indexed_read(self): with TestAreaContext("ecl_kw_indexed_read") as area: fortio = FortIO("index_test", mode=FortIO.WRITE_MODE) element_count = 100000 ecl_kw = EclKW.create("TEST", element_count, EclTypeEnum.ECL_INT_TYPE) for index in range(element_count): ecl_kw[index] = index ecl_kw.fwrite(fortio) fortio.close() fortio = FortIO("index_test", mode=FortIO.READ_MODE) new_ecl_kw = EclKW.fread(fortio) for index in range(element_count): self.assertEqual(new_ecl_kw[index], index) index_map = IntVector() index_map.append(2) index_map.append(3) index_map.append(5) index_map.append(7) index_map.append(11) index_map.append(13) index_map.append(313) index_map.append(1867) index_map.append(5227) index_map.append(7159) index_map.append(12689) index_map.append(18719) index_map.append(32321) index_map.append(37879) index_map.append(54167) index_map.append(77213) index_map.append(88843) index_map.append(99991) char_buffer = ctypes.create_string_buffer( len(index_map) * ctypes.sizeof(ctypes.c_int)) freadIndexedData(fortio, 24, EclTypeEnum.ECL_INT_TYPE, element_count, index_map, char_buffer) int_buffer = ctypes.cast(char_buffer, ctypes.POINTER(ctypes.c_int)) for index, index_map_value in enumerate(index_map): self.assertEqual(index_map_value, int_buffer[index])
def test_kw(self): kw1 = EclKW.create("KW1", 2, EclTypeEnum.ECL_INT_TYPE) kw2 = EclKW.create("KW2", 2, EclTypeEnum.ECL_INT_TYPE) kw1[0] = 99 kw1[1] = 77 kw2[0] = 113 kw2[1] = 335 with TestAreaContext("python/fortio/write-kw"): f = FortIO("test", FortIO.WRITE_MODE, fmt_file=False) kw1.fwrite(f) f = FortIO("test", FortIO.APPEND_MODE) kw2.fwrite(f) f = FortIO("test", fmt_file=False) k1 = EclKW.fread(f) k2 = EclKW.fread(f) self.assertTrue(k1.equal(kw1)) self.assertTrue(k2.equal(kw2))
def test_context(self): with TestAreaContext("python/fortio/context"): kw1 = EclKW.create("KW" , 2456 , EclTypeEnum.ECL_FLOAT_TYPE) for i in range(len(kw1)): kw1[i] = randint(0,1000) with openFortIO("file" , mode = FortIO.WRITE_MODE) as f: kw1.fwrite( f ) with openFortIO("file") as f: kw2 = EclKW.fread( f ) self.assertTrue( kw1 == kw2 )
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.create( "KW" , 27 , EclTypeEnum.ECL_FLOAT_TYPE ) kw_global_size = EclKW.create( "KW" , grid.getGlobalSize() , EclTypeEnum.ECL_FLOAT_TYPE ) kw_active_size = EclKW.create( "KW" , grid.getNumActive() , EclTypeEnum.ECL_FLOAT_TYPE ) 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_create(self): defRegion = RegionDefinition.create(5, self.faults, [ "DF4_MC", "DF15_MC", "DF43_MC", "DF25_LC", "DF21_C", "DF1_C", self.poly_file6, "DF26_MC", "DF34_MCS", "DF32_MC", self.poly_file5 ]) region_kw = EclKW.create("REGIONS", self.grid.getGlobalSize(), EclTypeEnum.ECL_INT_TYPE) region_kw.assign(0) for k in range(self.grid.getNZ()): with self.assertRaises(NotImplementedError): block_list = defRegion.findInternalBlocks( self.grid, self.fault_blocks[k])
def test_ecl_kw_indexed_read(self): with TestAreaContext("ecl_kw_indexed_read") as area: fortio = FortIO("index_test", mode=FortIO.WRITE_MODE) element_count = 100000 ecl_kw = EclKW.create("TEST", element_count, EclTypeEnum.ECL_INT_TYPE) for index in range(element_count): ecl_kw[index] = index ecl_kw.fwrite(fortio) fortio.close() fortio = FortIO("index_test", mode=FortIO.READ_MODE) new_ecl_kw = EclKW.fread(fortio) for index in range(element_count): self.assertEqual(new_ecl_kw[index], index) index_map = IntVector() index_map.append(2) index_map.append(3) index_map.append(5) index_map.append(7) index_map.append(11) index_map.append(13) index_map.append(313) index_map.append(1867) index_map.append(5227) index_map.append(7159) index_map.append(12689) index_map.append(18719) index_map.append(32321) index_map.append(37879) index_map.append(54167) index_map.append(77213) index_map.append(88843) index_map.append(99991) char_buffer = ctypes.create_string_buffer(len(index_map) * ctypes.sizeof(ctypes.c_int)) freadIndexedData(fortio, 24, EclTypeEnum.ECL_INT_TYPE, element_count, index_map, char_buffer) int_buffer = ctypes.cast(char_buffer, ctypes.POINTER(ctypes.c_int)) for index, index_map_value in enumerate(index_map): self.assertEqual(index_map_value, int_buffer[index])
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_update(self): reg1 = RegionDefinition(1) reg2 = RegionDefinition(2) self.assertTrue(not reg1.hasPolygon()) reg1.addEdge(self.poly1) reg2.addEdge(self.poly2) self.assertTrue(reg1.hasPolygon()) region_kw = EclKW.create("REGIONS", self.grid.getGlobalSize(), EclTypeEnum.ECL_INT_TYPE) region_kw.assign(0) block_list1 = [] block_list2 = [] with self.assertRaises(NotImplementedError): block_list1 = reg1.findInternalBlocks( self.grid, reg1.splitFaultBlocks(self.grid, self.fault_blocks[0])) with self.assertRaises(NotImplementedError): block_list2 = reg2.findInternalBlocks( self.grid, reg2.splitFaultBlocks(self.grid, self.fault_blocks[0])) if block_list1: for block in block_list1: region_id = reg1.getRegionID() block.assignToRegion(region_id) for g in block.getGlobalIndexList(): region_kw[g] = region_id if block_list2: for block in block_list2: region_id = reg2.getRegionID() block.assignToRegion(region_id) for g in block.getGlobalIndexList(): region_kw[g] = region_id for j in range(4): for i in range(4): g1 = i + j * self.grid.getNX() g2 = i + 12 + (j + 12) * self.grid.getNX()
def test_fprintf_data(self): with TestAreaContext("kw_no_header"): kw = EclKW.create("REGIONS", 10, EclTypeEnum.ECL_INT_TYPE) for i in range(len(kw)): kw[i] = i fileH = open("test", "w") kw.fprintf_data(fileH) fileH.close() fileH = open("test", "r") data = [] for line in fileH.readlines(): tmp = line.split() for elm in tmp: data.append(int(elm)) for (v1, v2) in zip(data, kw): self.assertEqual(v1, v2)
def test_fprintf_data(self): with TestAreaContext("kw_no_header"): kw = EclKW.create("REGIONS" , 10 , EclTypeEnum.ECL_INT_TYPE) for i in range(len(kw)): kw[i] = i fileH = open("test" , "w") kw.fprintf_data( fileH ) fileH.close() fileH = open("test" , "r") data = [] for line in fileH.readlines(): tmp = line.split() for elm in tmp: data.append( int(elm) ) for (v1,v2) in zip(data,kw): self.assertEqual(v1,v2)
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_update(self): reg1 = RegionDefinition( 1 ) reg2 = RegionDefinition( 2 ) self.assertTrue( not reg1.hasPolygon() ) reg1.addEdge( self.poly1 ) reg2.addEdge( self.poly2 ) self.assertTrue( reg1.hasPolygon() ) region_kw = EclKW.create( "REGIONS" , self.grid.getGlobalSize() , EclTypeEnum.ECL_INT_TYPE ) region_kw.assign( 0 ) block_list1 = [] block_list2 = [] with self.assertRaises(NotImplementedError): block_list1 = reg1.findInternalBlocks(self.grid , reg1.splitFaultBlocks(self.grid , self.fault_blocks[0])) with self.assertRaises(NotImplementedError): block_list2 = reg2.findInternalBlocks(self.grid , reg2.splitFaultBlocks(self.grid , self.fault_blocks[0])) if block_list1: for block in block_list1: region_id = reg1.getRegionID() block.assignToRegion( region_id ) for g in block.getGlobalIndexList(): region_kw[g] = region_id if block_list2: for block in block_list2: region_id = reg2.getRegionID() block.assignToRegion( region_id ) for g in block.getGlobalIndexList(): region_kw[g] = region_id for j in range(4): for i in range(4): g1 = i + j*self.grid.getNX() g2 = i + 12 + (j + 12)* self.grid.getNX()
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_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_ecl_kw_create(self): with self.assertRaises(DeprecationWarning): kw = EclKW.create("KW" , 1000 , EclTypeEnum.ECL_INT_TYPE)
def copy_long(): src = EclKW.create("NAME", 100, EclTypeEnum.ECL_FLOAT_TYPE) copy = src.sub_copy(0, 2000)
def copy_offset(): src = EclKW.create("NAME", 100, EclTypeEnum.ECL_FLOAT_TYPE) copy = src.sub_copy(200, 100)
def exportACTNUMKw(self): actnum = EclKW.create("ACTNUM" , self.getGlobalSize() , EclTypeEnum.ECL_INT_TYPE) cfunc.init_actnum( self , actnum.getDataPtr() ) return actnum
def test_create(self): with self.assertRaises(ValueError): EclKW.create( "ToGodDamnLong" , 100 , EclTypeEnum.ECL_CHAR_TYPE )
def test_create(self): with self.assertRaises(ValueError): EclKW.create("ToGodDamnLong", 100, EclTypeEnum.ECL_CHAR_TYPE)
def exportACTNUMKw(self): actnum = EclKW.create("ACTNUM", self.getGlobalSize(), EclTypeEnum.ECL_INT_TYPE) cfunc.init_actnum(self, actnum.getDataPtr()) return actnum
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.size ) layer = FaultBlockLayer( self.grid , 1 ) self.assertEqual( 1 , layer.getK() ) kw = EclKW.create( "FAULTBLK" , self.grid.size , EclTypeEnum.ECL_FLOAT_TYPE ) 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()))