Exemple #1
0
def createContainmentTestBase():
    return [
            (3,  GridGen.create_grid((6,6,6), (1,1,1), offset=1)),
            (10, GridGen.create_grid((3,3,3), (1,1,1), offset=1, concave=True)),
            (4,  GridGen.create_grid((10,10,1), (1,1,1), offset=0., misalign=True)),
            (3,
                GridGen.create_grid((6,6,6), (1,1,1), offset=0.,
                    escape_origo_shift=(100, 100, 0),
                    irregular_offset=True, concave=True, irregular=True,
                    scale=1.5, translation=(5,5,0),
                    misalign=True
                    )
                )
            ]
Exemple #2
0
 def setUp(self):
     self.test_base = [
         (list(GridGen.create_coord((4, 4, 4), (1, 1, 1))),
          list(GridGen.create_zcorn((4, 4, 4), (1, 1, 1), offset=0)),
          GridGen.create_grid((4, 4, 4), (1, 1, 1), offset=0)),
         (list(
             GridGen.create_coord((5, 5, 5), (1, 1, 1),
                                  translation=(10, 10, 0))),
          list(
              GridGen.create_zcorn((5, 5, 5), (1, 1, 1),
                                   offset=0.5,
                                   irregular_offset=True,
                                   concave=True,
                                   irregular=True)),
          GridGen.create_grid((5, 5, 5), (1, 1, 1),
                              offset=0.5,
                              irregular=True,
                              irregular_offset=True,
                              concave=True,
                              translation=(10, 10, 0)))
     ]
Exemple #3
0
    def test_subgrid_translation(self):
        grid = GridGen.create_grid((4, 4, 4), (1, 1, 1),
                                   offset=0.5,
                                   irregular=True,
                                   irregular_offset=True,
                                   concave=True,
                                   translation=(10, 10, 0))

        # Create grid with MAPAXES
        mapaxes = EclKW("MAPAXES", 6, EclDataType.ECL_FLOAT)
        for i, val in enumerate([1200, 1400, 2500, 2500, 3700, 4000]):
            mapaxes[i] = val

        grid = EclGrid.create(grid.getDims(),
                              grid.export_zcorn(),
                              grid.export_coord(),
                              None,
                              mapaxes=mapaxes)

        for translation in [(0, 0, 0), (10, 10, 100), (-1, -1, -1)]:
            subgrid = GridGen.extract_subgrid(grid, ((0, 3), (0, 3), (0, 3)),
                                              translation=translation)

            self.assertEqual(grid.getDims(), subgrid.getDims())

            translation = numpy.array(translation)
            for gindex in range(grid.getGlobalSize()):
                grid_corners = [
                    grid.getCellCorner(i, global_index=gindex)
                    for i in range(8)
                ]

                subgrid_corners = [
                    subgrid.getCellCorner(i, global_index=gindex)
                    for i in range(8)
                ]

                subgrid_corners = [
                    list(numpy.array(corner) - translation)
                    for corner in subgrid_corners
                ]

                for gc, sc in zip(grid_corners, subgrid_corners):
                    self.assertAlmostEqualList(
                        gc,
                        sc,
                        msg="Failed to translate corners correctly." +
                        "Expected %s, was %s." % (gc, sc),
                        tolerance=10e-10)
Exemple #4
0
def createVolumeTestGridBase(dim, dV, offset=1):
    return [
        GridGen.create_grid(dim, dV, offset=0),
        GridGen.create_grid(dim, dV, offset=offset),
        GridGen.create_grid(dim, dV, offset=offset, irregular_offset=True),
        GridGen.create_grid(dim, dV, offset=offset, concave=True),
        GridGen.create_grid(dim, dV, offset=offset, irregular=True),
        GridGen.create_grid(dim,
                            dV,
                            offset=offset,
                            concave=True,
                            irregular=True),
        GridGen.create_grid(dim,
                            dV,
                            offset=offset,
                            irregular_offset=True,
                            concave=True),
        GridGen.create_grid(dim, dV, offset=0, faults=True),
        GridGen.create_grid(dim, dV, offset=offset, faults=True),
        GridGen.create_grid(dim, dV, escape_origo_shift=(100, 100, 0),
                            scale=2),
        GridGen.create_grid(dim,
                            dV,
                            escape_origo_shift=(100, 100, 0),
                            scale=0.5),
        GridGen.create_grid(dim,
                            dV,
                            escape_origo_shift=(100, 100, 0),
                            translation=(50, 50, 0)),
        GridGen.create_grid(dim,
                            dV,
                            escape_origo_shift=(100, 100, 0),
                            rotate=True),
        GridGen.create_grid(dim,
                            dV,
                            escape_origo_shift=(100, 100, 0),
                            misalign=True),
        GridGen.create_grid(dim,
                            dV,
                            offset=offset,
                            escape_origo_shift=(100, 100, 0),
                            irregular_offset=True,
                            concave=True,
                            irregular=True,
                            scale=1.5,
                            translation=(5, 5, 0),
                            rotate=True,
                            misalign=True)
    ]