コード例 #1
0
    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]
コード例 #2
0
    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)
コード例 #3
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=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)
コード例 #4
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)
コード例 #5
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)