def splitFaultBlockClosedPolygon( grid , fault_blocks , polygon ):
"""
Special case code when the region is limited only by one polygon.
"""
new_fault_blocks = FaultBlockLayer( grid , fault_blocks.getK() )
new_block = new_fault_blocks.addBlock()
for block in fault_blocks:
for p in block:
if GeometryTools.pointInPolygon( (p.x , p.y) , polygon ):
new_block.addCell(p.i , p.j)
return new_fault_blocks
def splitFaultBlocks(self , grid , fault_blocks ):
boundingPolygon = Polyline(init_points = grid.getBoundingBox2D())
boundingPolygon.assertClosed()
if self.hasPolygon():
if len(self.edges) == 1:
return self.splitFaultBlockClosedPolygon( grid , fault_blocks , self.edges[0] )
else:
current_fault_block_layer = fault_blocks
k = fault_blocks.getK()
for edge in self.edges:
if isinstance(edge , Polyline):
# Start on a brand new fault block layer.
next_fault_block_layer = FaultBlockLayer( grid , k )
for block in current_fault_block_layer:
if block.containsPolyline(edge):
print "Block %d is split due to edge:%s" % (block.getBlockID() , edge.name())
sliced = GeometryTools.slicePolygon( boundingPolygon , edge )
inside_list = []
outside_list = []
for p in block:
if GeometryTools.pointInPolygon( (p.x , p.y) , sliced ):
inside_list.append( p )
else:
outside_list.append( p )
if len(inside_list) * len(outside_list) == 0:
new_block = next_fault_block_layer.addBlock( )
for p in inside_list:
new_block.addCell(p.i , p.j)
for p in outside_list:
new_block.addCell(p.i , p.j)
else:
layer = Layer( grid.getNX() , grid.getNY() )
for p in inside_list:
layer[p.i , p.j] = 1
for p in outside_list:
layer[p.i , p.j] = 2
next_fault_block_layer.scanLayer( layer )
else:
next_fault_block_layer.insertBlockContent( block )
current_fault_block_layer = next_fault_block_layer
return current_fault_block_layer
else:
return fault_blocks
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()))
