def loadGrid(self):
grid_file = self.createTestPath("Statoil/ECLIPSE/Faults/grid.grdecl")
fileH = open(grid_file, "r")
specgrid = EclKW.read_grdecl(fileH, "SPECGRID", ecl_type=EclTypeEnum.ECL_INT_TYPE, strict=False)
zcorn = EclKW.read_grdecl(fileH, "ZCORN")
coord = EclKW.read_grdecl(fileH, "COORD")
actnum = EclKW.read_grdecl(fileH, "ACTNUM", ecl_type=EclTypeEnum.ECL_INT_TYPE)
return EclGrid.create(specgrid, zcorn, coord, actnum)
def create(self, filename, load_actnum=True):
fileH = open(filename, "r")
specgrid = EclKW.read_grdecl(fileH, "SPECGRID", ecl_type=EclTypeEnum.ECL_INT_TYPE, strict=False)
zcorn = EclKW.read_grdecl(fileH, "ZCORN")
coord = EclKW.read_grdecl(fileH, "COORD")
if load_actnum:
actnum = EclKW.read_grdecl(fileH, "ACTNUM", ecl_type=EclTypeEnum.ECL_INT_TYPE)
else:
actnum = None
mapaxes = EclKW.read_grdecl(fileH, "MAPAXES")
grid = EclGrid.create(specgrid, zcorn, coord, actnum, mapaxes=mapaxes)
return grid
def create(self, filename, load_actnum=True):
fileH = open(filename, "r")
specgrid = EclKW.read_grdecl(fileH, "SPECGRID", ecl_type=EclTypeEnum.ECL_INT_TYPE, strict=False)
zcorn = EclKW.read_grdecl(fileH, "ZCORN")
coord = EclKW.read_grdecl(fileH, "COORD")
if load_actnum:
actnum = EclKW.read_grdecl(fileH, "ACTNUM", ecl_type=EclTypeEnum.ECL_INT_TYPE)
else:
actnum = None
mapaxes = EclKW.read_grdecl(fileH, "MAPAXES")
grid = EclGrid.create(specgrid, zcorn, coord, actnum, mapaxes=mapaxes)
return grid
def loadFromGrdecl(cls, filename):
"""Will create a new EclGrid instance from grdecl file.
This function will scan the input file @filename and look for
the keywords required to build a grid. The following keywords
are required:
SPECGRID ZCORN COORD
In addition the function will look for and use the ACTNUM and
MAPAXES keywords if they are found; if ACTNUM is not found all
cells are assumed to be active.
Slightly more exotic grid concepts like dual porosity, NNC
mapping, LGR and coarsened cells will be completely ignored;
if you need such concepts you must have an EGRID file and use
the default EclGrid() constructor - that is also considerably
faster.
"""
if os.path.isfile(filename):
with open(filename) as f:
specgrid = EclKW.read_grdecl(f,
"SPECGRID",
ecl_type=EclTypeEnum.ECL_INT_TYPE,
strict=False)
zcorn = EclKW.read_grdecl(f, "ZCORN")
coord = EclKW.read_grdecl(f, "COORD")
actnum = EclKW.read_grdecl(f,
"ACTNUM",
ecl_type=EclTypeEnum.ECL_INT_TYPE)
mapaxes = EclKW.read_grdecl(f, "MAPAXES")
if specgrid is None:
raise ValueError(
"The grdecl file:%s was invalid - could not find SPECGRID keyword"
% filename)
if zcorn is None:
raise ValueError(
"The grdecl file:%s was invalid - could not find ZCORN keyword"
% filename)
if coord is None:
raise ValueError(
"The grdecl file:%s was invalid - could not find COORD keyword"
% filename)
return EclGrid.create(specgrid, zcorn, coord, actnum, mapaxes)
else:
raise IOError("No such file:%s" % filename)
def loadGrid(self):
grid_file = self.createTestPath("Statoil/ECLIPSE/Faults/grid.grdecl")
fileH = open(grid_file, "r")
specgrid = EclKW.read_grdecl(fileH,
"SPECGRID",
ecl_type=EclDataType.ECL_INT,
strict=False)
zcorn = EclKW.read_grdecl(fileH, "ZCORN")
coord = EclKW.read_grdecl(fileH, "COORD")
actnum = EclKW.read_grdecl(fileH,
"ACTNUM",
ecl_type=EclDataType.ECL_INT)
return EclGrid.create(specgrid, zcorn, coord, actnum)
def loadGrid(path, load_actnum=True):
""" @rtype: EclGrid """
with open(path, "r") as f:
specgrid = EclKW.read_grdecl(f, "SPECGRID", ecl_type=EclTypeEnum.ECL_INT_TYPE, strict=False)
zcorn = EclKW.read_grdecl(f, "ZCORN")
coord = EclKW.read_grdecl(f, "COORD")
actnum = None
if load_actnum:
actnum = EclKW.read_grdecl(f, "ACTNUM", ecl_type=EclTypeEnum.ECL_INT_TYPE)
mapaxes = EclKW.read_grdecl(f, "MAPAXES")
grid = EclGrid.create(specgrid, zcorn, coord, actnum, mapaxes=mapaxes)
return grid
def loadGrid(path, load_actnum=True):
""" @rtype: EclGrid """
with open(path, "r") as f:
specgrid = EclKW.read_grdecl(f, "SPECGRID", ecl_type=EclTypeEnum.ECL_INT_TYPE, strict=False)
zcorn = EclKW.read_grdecl(f, "ZCORN")
coord = EclKW.read_grdecl(f, "COORD")
actnum = None
if load_actnum:
actnum = EclKW.read_grdecl(f, "ACTNUM", ecl_type=EclTypeEnum.ECL_INT_TYPE)
mapaxes = EclKW.read_grdecl(f, "MAPAXES")
grid = EclGrid.create(specgrid, zcorn, coord, actnum, mapaxes=mapaxes)
return grid
def test_Load( self ):
kw = EclKW.read_grdecl(open(self.src_file, "r"), "PERMX")
self.assertTrue(kw)
grid = EclGrid( self.createTestPath("Statoil/ECLIPSE/Gurbat/ECLIPSE" ))
kw = Ecl3DKW.read_grdecl(grid , open(self.src_file, "r"), "PERMX")
self.assertTrue( isinstance( kw , Ecl3DKW ))
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_Load(self):
kw = EclKW.read_grdecl(open(self.src_file, "r"), "PERMX")
self.assertTrue(kw)
grid = EclGrid(self.createTestPath("Statoil/ECLIPSE/Gurbat/ECLIPSE"))
kw = Ecl3DKW.read_grdecl(grid, open(self.src_file, "r"), "PERMX")
self.assertTrue(isinstance(kw, Ecl3DKW))
def setUp(self):
self.grid = EclGrid(
self.createTestPath("Statoil/ECLIPSE/Mariner/MARINER.EGRID"))
fileH = open(
self.createTestPath("Statoil/ECLIPSE/Mariner/faultblock.grdecl"))
self.kw = EclKW.read_grdecl(fileH,
"FAULTBLK",
ecl_type=EclTypeEnum.ECL_INT_TYPE)
def test_reload( self ):
kw = EclKW.read_grdecl(open(self.src_file, "r"), "PERMX")
tmp_file1 = "/tmp/permx1.grdecl"
tmp_file2 = "/tmp/permx2.grdecl"
self.addFile(tmp_file1)
self.addFile(tmp_file2)
fileH = open(tmp_file1, "w")
kw.write_grdecl(fileH)
fileH.close()
kw1 = EclKW.read_grdecl(open(tmp_file1, "r"), "PERMX")
fileH = open(tmp_file2, "w")
kw1.write_grdecl(fileH)
fileH.close()
self.assertFilesAreEqual(tmp_file1, tmp_file2)
def test_reload(self):
kw = EclKW.read_grdecl(open(self.src_file, "r"), "PERMX")
tmp_file1 = "/tmp/permx1.grdecl"
tmp_file2 = "/tmp/permx2.grdecl"
self.addFile(tmp_file1)
self.addFile(tmp_file2)
fileH = open(tmp_file1, "w")
kw.write_grdecl(fileH)
fileH.close()
kw1 = EclKW.read_grdecl(open(tmp_file1, "r"), "PERMX")
fileH = open(tmp_file2, "w")
kw1.write_grdecl(fileH)
fileH.close()
self.assertFilesAreEqual(tmp_file1, tmp_file2)
def test_fseek( self ):
file = open(self.src_file, "r")
self.assertTrue(EclKW.fseek_grdecl(file, "PERMX"))
self.assertFalse(EclKW.fseek_grdecl(file, "PERMY"))
file.close()
file = open(self.src_file, "r")
kw1 = EclKW.read_grdecl(file, "PERMX")
self.assertFalse(EclKW.fseek_grdecl(file, "PERMX"))
self.assertTrue(EclKW.fseek_grdecl(file, "PERMX", rewind=True))
file.close()
def test_fseek(self):
file = open(self.src_file, "r")
self.assertTrue(EclKW.fseek_grdecl(file, "PERMX"))
self.assertFalse(EclKW.fseek_grdecl(file, "PERMY"))
file.close()
file = open(self.src_file, "r")
kw1 = EclKW.read_grdecl(file, "PERMX")
self.assertFalse(EclKW.fseek_grdecl(file, "PERMX"))
self.assertTrue(EclKW.fseek_grdecl(file, "PERMX", rewind=True))
file.close()
def loadFromGrdecl(cls , filename):
"""Will create a new EclGrid instance from grdecl file.
This function will scan the input file @filename and look for
the keywords required to build a grid. The following keywords
are required:
SPECGRID ZCORN COORD
In addition the function will look for and use the ACTNUM and
MAPAXES keywords if they are found; if ACTNUM is not found all
cells are assumed to be active.
Slightly more exotic grid concepts like dual porosity, NNC
mapping, LGR and coarsened cells will be completely ignored;
if you need such concepts you must have an EGRID file and use
the default EclGrid() constructor - that is also considerably
faster.
"""
if os.path.isfile(filename):
with open(filename) as f:
specgrid = EclKW.read_grdecl(f, "SPECGRID", ecl_type=EclTypeEnum.ECL_INT_TYPE, strict=False)
zcorn = EclKW.read_grdecl(f, "ZCORN")
coord = EclKW.read_grdecl(f, "COORD")
actnum = EclKW.read_grdecl(f, "ACTNUM", ecl_type=EclTypeEnum.ECL_INT_TYPE)
mapaxes = EclKW.read_grdecl(f, "MAPAXES")
if specgrid is None:
raise ValueError("The grdecl file:%s was invalid - could not find SPECGRID keyword" % filename)
if zcorn is None:
raise ValueError("The grdecl file:%s was invalid - could not find ZCORN keyword" % filename)
if coord is None:
raise ValueError("The grdecl file:%s was invalid - could not find COORD keyword" % filename)
return EclGrid.create( specgrid , zcorn , coord , actnum , mapaxes )
else:
raise IOError("No such file:%s" % filename)
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_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 = EclTypeEnum.ECL_INT_TYPE)
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 )
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 setUp(self):
self.grid = EclGrid(
self.createTestPath("Statoil/ECLIPSE/Mariner/MARINER.EGRID"))
with open(
self.createTestPath(
"Statoil/ECLIPSE/Mariner/faultblock.grdecl")) as fileH:
self.kw = EclKW.read_grdecl(fileH,
"FAULTBLK",
ecl_type=EclTypeEnum.ECL_INT_TYPE)
self.faults = FaultCollection(
self.grid,
self.createTestPath("Statoil/ECLIPSE/Mariner/faults.grdecl"))
self.poly_file1 = self.createTestPath(
"Statoil/ECLIPSE/Mariner/pol1.xyz")
self.poly_file2 = self.createTestPath(
"Statoil/ECLIPSE/Mariner/pol2.xyz")
self.poly_file3 = self.createTestPath(
"Statoil/ECLIPSE/Mariner/pol3.xyz")
self.poly_file4 = self.createTestPath(
"Statoil/ECLIPSE/Mariner/pol4.xyz")
self.poly_file5 = self.createTestPath(
"Statoil/ECLIPSE/Mariner/pol5.xyz")
self.poly_file6 = self.createTestPath(
"Statoil/ECLIPSE/Mariner/pol6.xyz")
self.poly_file7 = self.createTestPath(
"Statoil/ECLIPSE/Mariner/pol7.xyz")
self.poly_file8 = self.createTestPath(
"Statoil/ECLIPSE/Mariner/pol8.xyz")
self.poly_file9 = self.createTestPath(
"Statoil/ECLIPSE/Mariner/pol9.xyz")
self.poly_file10 = self.createTestPath(
"Statoil/ECLIPSE/Mariner/pol10.xyz")
self.poly_file11 = self.createTestPath(
"Statoil/ECLIPSE/Mariner/pol11.xyz")
self.fault_blocks = []
for k in range(self.grid.getNZ()):
blocks = FaultBlockLayer(self.grid, k)
blocks.scanKeyword(self.kw)
self.fault_blocks.append(blocks)
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=EclTypeEnum.ECL_INT_TYPE)
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_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 = EclTypeEnum.ECL_INT_TYPE)
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 setUp(self):
self.grid = EclGrid( self.createTestPath("Statoil/ECLIPSE/Mariner/MARINER.EGRID"))
with open( self.createTestPath("Statoil/ECLIPSE/Mariner/faultblock.grdecl") ) as fileH:
self.kw = EclKW.read_grdecl( fileH , "FAULTBLK" , ecl_type = EclTypeEnum.ECL_INT_TYPE )
self.faults = FaultCollection( self.grid , self.createTestPath("Statoil/ECLIPSE/Mariner/faults.grdecl"))
self.poly_file1 = self.createTestPath("Statoil/ECLIPSE/Mariner/pol1.xyz")
self.poly_file2 = self.createTestPath("Statoil/ECLIPSE/Mariner/pol2.xyz")
self.poly_file3 = self.createTestPath("Statoil/ECLIPSE/Mariner/pol3.xyz")
self.poly_file4 = self.createTestPath("Statoil/ECLIPSE/Mariner/pol4.xyz")
self.poly_file5 = self.createTestPath("Statoil/ECLIPSE/Mariner/pol5.xyz")
self.poly_file6 = self.createTestPath("Statoil/ECLIPSE/Mariner/pol6.xyz")
self.poly_file7 = self.createTestPath("Statoil/ECLIPSE/Mariner/pol7.xyz")
self.poly_file8 = self.createTestPath("Statoil/ECLIPSE/Mariner/pol8.xyz")
self.poly_file9 = self.createTestPath("Statoil/ECLIPSE/Mariner/pol9.xyz")
self.poly_file10 = self.createTestPath("Statoil/ECLIPSE/Mariner/pol10.xyz")
self.poly_file11 = self.createTestPath("Statoil/ECLIPSE/Mariner/pol11.xyz")
self.fault_blocks = []
for k in range(self.grid.getNZ()):
blocks = FaultBlockLayer( self.grid , k)
blocks.scanKeyword( self.kw )
self.fault_blocks.append( blocks )
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 = EclTypeEnum.ECL_INT_TYPE)
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 setUp(self):
self.grid = EclGrid( self.createTestPath("Statoil/ECLIPSE/Mariner/MARINER.EGRID"))
fileH = open( self.createTestPath("Statoil/ECLIPSE/Mariner/faultblock.grdecl") )
self.kw = EclKW.read_grdecl( fileH , "FAULTBLK" , ecl_type = EclDataType.ECL_INT )
def loadKW(keyword, ecl_type, path):
""" @rtype: EclKW """
with open(path, "r") as f:
kw_data = EclKW.read_grdecl(f, keyword, ecl_type=ecl_type)
return kw_data
def test_Load(self):
kw = EclKW.read_grdecl(open(self.src_file, "r"), "PERMX")
self.assertTrue(kw)
def loadKW(keyword, ecl_type, path):
""" @rtype: EclKW """
with open(path, "r") as f:
kw_data = EclKW.read_grdecl(f, keyword, ecl_type=ecl_type)
return kw_data
def test_Load( self ):
kw = EclKW.read_grdecl(open(self.src_file, "r"), "PERMX")
self.assertTrue(kw)
