xtgeo 4.14.1__cp313-cp313-win_amd64.whl

xtgeo/grid3d/_grid_export.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import io
+import json
+import struct
+from contextlib import ExitStack
+from copy import deepcopy
+from typing import IO, TYPE_CHECKING, Any, Literal
+
+import h5py
+import hdf5plugin
+import roffio
+
+from xtgeo.common import null_logger
+
+from ._egrid import EGrid
+from ._grdecl_grid import GrdeclGrid
+from ._roff_grid import RoffGrid
+
+logger = null_logger(__name__)
+
+if TYPE_CHECKING:
+    import numpy as np
+
+    from xtgeo.common.types import FileLike
+    from xtgeo.io._file import FileWrapper
+    from xtgeo.metadata.metata import MetaData
+
+    from .grid import Grid
+
+# valid byte settings for xtgeo/hdf5 based export e.g. 441 means
+# 4byte float for coord, 4byte float for zcorn, and 1 byte Int for actnums.
+# Native XTGeo is 844
+VALIDXTGFMT = (221, 421, 441, 444, 841, 844, 881, 884)
+
+
+def export_roff(
+    grid: Grid, gfile: FileLike, roff_format: Literal["ascii", "binary"] = "binary"
+) -> None:
+    """Export grid to ROFF format."""
+    if roff_format == "binary":
+        RoffGrid.from_xtgeo_grid(grid).to_file(gfile, roff_format=roffio.Format.BINARY)
+    elif roff_format == "ascii":
+        RoffGrid.from_xtgeo_grid(grid).to_file(gfile, roff_format=roffio.Format.ASCII)
+    else:
+        raise ValueError(
+            "Incorrect format specifier in export_roff,"
+            f" expected 'binary' or 'ascii, got {roff_format}"
+        )
+
+
+def export_grdecl(grid: Grid, gfile: FileLike, mode: int, rle: bool = False) -> None:
+    """Export grid to Eclipse GRDECL format (ascii, mode=1) or binary (mode=0).
+    Optionally for ASCII GRDECL, run-length encoding RLE can be applied"""
+    fileformat = "grdecl" if mode == 1 else "bgrdecl"
+    GrdeclGrid.from_xtgeo_grid(grid).to_file(gfile, fileformat=fileformat, rle=rle)
+
+
+def export_egrid(grid: Grid, gfile: FileLike) -> None:
+    """Export grid to Eclipse EGRID format, binary."""
+    EGrid.from_xtgeo_grid(grid).to_file(gfile, fileformat="egrid")
+
+
+def export_fegrid(grid: Grid, gfile: FileLike) -> None:
+    """Export grid to Eclipse FEGRID format, ascii."""
+    EGrid.from_xtgeo_grid(grid).to_file(gfile, fileformat="fegrid")
+
+
+def export_xtgcpgeom(grid: Grid, gfile: FileWrapper, subformat: int = 844) -> None:
+    """Export grid to binary XTGeo xtgcpgeom format, in prep. and experimental."""
+    logger.info("Export to native binary xtgeo...")
+
+    grid._set_xtgformat2()
+    logger.info("Export to native binary xtgeo...(2)")
+
+    grid.metadata.required = grid
+    meta = grid.metadata.get_metadata()
+
+    # subformat processing, indicating number of bytes per datatype
+    # here, 844 is native XTGeo (float64, float32, int32)
+    dtypecoo, dtypezco, dtypeact, meta = _define_dtypes(grid, subformat, meta)
+
+    coordsv, zcornsv, actnumsv = _transform_vectors(
+        grid, meta, dtypecoo, dtypezco, dtypeact
+    )
+
+    prevalues = (1, 1301, int(subformat), grid.ncol, grid.nrow, grid.nlay)
+    mystruct = struct.Struct("= i i i q q q")
+    hdr = mystruct.pack(*prevalues)
+
+    # Convert StringIO to BytesIO as this is a binary format
+    with ExitStack() as stack:
+        if isinstance(gfile.file, io.StringIO):
+            data = gfile.file.getvalue().encode("utf-8")
+            fout: IO[Any] = io.BytesIO(data)
+        elif isinstance(gfile.file, io.BytesIO):
+            fout = gfile.file
+        else:
+            fout = stack.enter_context(open(gfile.file, "wb"))
+        fout.write(hdr)
+        coordsv.tofile(fout)
+        zcornsv.tofile(fout)
+        actnumsv.tofile(fout)
+        fout.write("\nXTGMETA.v01\n".encode())
+        fout.write(json.dumps(meta).encode())
+
+    logger.info("Export to native binary xtgeo... done!")
+
+
+def export_hdf5_cpgeom(
+    grid: Grid,
+    gfile: FileWrapper,
+    compression: Literal["blosc"] | None = None,
+    chunks: bool = False,
+    subformat: int = 844,
+) -> None:
+    """Export grid to h5/hdf5, in prep. and experimental."""
+    grid._set_xtgformat2()
+
+    logger.debug("Export to hdf5 xtgeo layout...")
+
+    grid.metadata.required = grid
+    meta = grid.metadata.get_metadata()
+
+    if compression == "blosc":
+        compression = hdf5plugin.Blosc(
+            cname="blosclz", clevel=9, shuffle=hdf5plugin.Blosc.SHUFFLE
+        )
+
+    dtypecoo, dtypezco, dtypeact, meta = _define_dtypes(grid, subformat, meta)
+    coordsv, zcornsv, actnumsv = _transform_vectors(
+        grid, meta, dtypecoo, dtypezco, dtypeact
+    )
+    jmeta = json.dumps(meta).encode()
+
+    with h5py.File(gfile.name, "w") as fh5:
+        grp = fh5.create_group("CornerPointGeometry")
+        grp.create_dataset(
+            "coord",
+            data=coordsv,
+            compression=compression,
+            chunks=chunks or None,
+        )
+        grp.create_dataset(
+            "zcorn",
+            data=zcornsv,
+            compression=compression,
+            chunks=chunks or None,
+        )
+        grp.create_dataset(
+            "actnum",
+            data=actnumsv,
+            compression=compression,
+            chunks=chunks or None,
+        )
+
+        grp.attrs["metadata"] = jmeta
+        grp.attrs["provider"] = "xtgeo"
+        grp.attrs["format-idcode"] = 1301
+
+    logger.debug("Export to hdf5 xtgeo layout... done!")
+
+
+def _define_dtypes(grid: Grid, fmt: int, meta: MetaData) -> tuple[str, str, str, str]:
+    # subformat processing, indicating number of bytes per datatype
+    # here, 844 is native XTGeo (float64, float32, int32)
+    logger.debug("Define dtypes...")
+
+    newmeta = deepcopy(meta)
+
+    if int(fmt) not in VALIDXTGFMT:
+        raise ValueError(f"The subformat value is not valid, must be in: {VALIDXTGFMT}")
+
+    if fmt <= 444:
+        # the float() is for JSON serialization which cannot handle float32
+        newmeta["_required_"]["xshift"] = float(grid._coordsv[:, :, 0::3].mean())
+        newmeta["_required_"]["yshift"] = float(grid._coordsv[:, :, 1::3].mean())
+        newmeta["_required_"]["zshift"] = float(grid._zcornsv.mean())
+
+    nbytecoord, nbytezcorn, nbyteactnum = [int(nbyte) for nbyte in str(fmt)]
+
+    dtype_coord = "float" + str(nbytecoord * 8)
+    dtype_zcorn = "float" + str(nbytezcorn * 8)
+    dtype_actnum = "int" + str(nbyteactnum * 8)
+
+    logger.debug("Define dtypes... done!")
+    return dtype_coord, dtype_zcorn, dtype_actnum, newmeta
+
+
+def _transform_vectors(
+    grid: Grid, meta: MetaData, dtypecoo: str, dtypezco: str, dtypeact: str
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    logger.debug("Transform vectors...")
+
+    xshift = meta["_required_"]["xshift"]
+    yshift = meta["_required_"]["yshift"]
+    zshift = meta["_required_"]["zshift"]
+
+    if xshift != 0.0 or yshift != 0.0 or zshift != 0.0:
+        coordsv = grid._coordsv.copy()
+        zcornsv = grid._zcornsv.copy()
+        actnumsv = grid._actnumsv.copy()
+        coordsv[:, :, 0::3] -= xshift
+        coordsv[:, :, 1::3] -= yshift
+        coordsv[:, :, 2::3] -= zshift
+        zcornsv -= zshift
+    else:
+        coordsv = grid._coordsv
+        zcornsv = grid._zcornsv
+        actnumsv = grid._actnumsv
+
+    if dtypecoo != "float64":
+        coordsv = coordsv.astype(dtypecoo)
+
+    if dtypecoo != "float32":
+        zcornsv = zcornsv.astype(dtypezco)
+
+    if dtypecoo != "int32":
+        actnumsv = actnumsv.astype(dtypeact)
+
+    logger.debug("Transform vectors... done!")
+    return coordsv, zcornsv, actnumsv

xtgeo/grid3d/_grid_hybrid.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+import xtgeo._internal as _internal  # type: ignore
+from xtgeo.common import null_logger
+
+logger = null_logger(__name__)
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d import Grid, GridProperty
+
+
+def make_hybridgrid(
+    self: Grid,
+    nhdiv: int = 10,
+    toplevel: float = 1000.0,
+    bottomlevel: float = 1100.0,
+    region: GridProperty | None = None,
+    region_number: int | None = None,
+) -> None:
+    """Make hybrid grid."""
+    self._set_xtgformat2()
+
+    newnlay = self.nlay * 2 + nhdiv
+
+    grid3d_cpp = _internal.grid3d.Grid(self)
+    region_array = (
+        region.values.astype(np.int32)
+        if region
+        else np.empty((0, 0, 0), dtype=np.int32)
+    )
+    hyb_zcornsv, hyb_actnumsv = grid3d_cpp.convert_to_hybrid_grid(
+        toplevel,
+        bottomlevel,
+        nhdiv,
+        region_array,
+        int(region_number) if region_number is not None else -1,
+    )
+
+    # when a hybridgrid is made, the current subrid settings lose relevance, hence
+    # it is forced set to None
+    self.subgrids = None
+
+    # update the grid in place
+    self._nlay = newnlay
+    self._zcornsv = hyb_zcornsv
+    self._actnumsv = hyb_actnumsv.astype(np.int32)

xtgeo/grid3d/_grid_import.py

@@ -0,0 +1,79 @@
+"""Grid import functions for various formats."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from xtgeo.common.exceptions import InvalidFileFormatError
+from xtgeo.common.log import null_logger
+from xtgeo.io._file import FileFormat, FileWrapper
+
+from . import _grid_import_ecl, _grid_import_roff, _grid_import_xtgcpgeom
+
+logger = null_logger(__name__)
+
+
+def from_file(
+    gfile: FileWrapper,
+    fformat: FileFormat,
+    **kwargs: Any,
+) -> dict[str, Any]:
+    """Import grid geometry from file, and makes an instance of this class.
+
+    Returns:
+    dictionary of keyword arguments to be used in Grid constructor.
+    """
+    if not isinstance(gfile, FileWrapper):
+        raise RuntimeError("Error gfile must be a FileWrapper instance")
+
+    result: dict[str, Any] = {
+        "filesrc": gfile.name,
+    }
+    gfile.check_file(raiseerror=IOError, raisetext=f"Cannot access file {gfile.name}")
+
+    if fformat in (FileFormat.ROFF_BINARY, FileFormat.ROFF_ASCII):
+        result.update(_grid_import_roff.import_roff(gfile, **kwargs))
+    elif fformat in (FileFormat.EGRID, FileFormat.FEGRID):
+        result.update(
+            _grid_import_ecl.import_ecl_egrid(
+                gfile,
+                fileformat=fformat,
+                **kwargs,
+            )
+        )
+    elif fformat == FileFormat.GRDECL:
+        result.update(_grid_import_ecl.import_ecl_grdecl(gfile, **kwargs))
+    elif fformat == FileFormat.BGRDECL:
+        result.update(_grid_import_ecl.import_ecl_bgrdecl(gfile, **kwargs))
+    elif fformat == FileFormat.XTG:
+        result.update(_grid_import_xtgcpgeom.import_xtgcpgeom(gfile, **kwargs))
+    elif fformat == FileFormat.HDF:
+        result.update(_grid_import_xtgcpgeom.import_hdf5_cpgeom(gfile, **kwargs))
+    else:
+        extensions = FileFormat.extensions_string(
+            [
+                FileFormat.ROFF_BINARY,
+                FileFormat.ROFF_ASCII,
+                FileFormat.EGRID,
+                FileFormat.FEGRID,
+                FileFormat.GRDECL,
+                FileFormat.BGRDECL,
+                FileFormat.XTG,
+                FileFormat.HDF,
+            ]
+        )
+        raise InvalidFileFormatError(
+            f"File format {fformat} is invalid for type Grid. "
+            f"Supported formats are {extensions}."
+        )
+
+    if gfile.memstream:
+        result["name"] = "unknown"
+    else:
+        # Mypy does not know that if gfile.memstream -> False
+        # then .file must be Path.
+        assert isinstance(gfile.file, Path)
+        result["name"] = gfile.file.stem
+
+    return result

xtgeo/grid3d/_grid_import_ecl.py

@@ -0,0 +1,101 @@
+"""Grid import functions for Eclipse, new approach (i.e. version 2)."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from xtgeo.common import null_logger
+from xtgeo.grid3d._egrid import EGrid, RockModel
+from xtgeo.grid3d._grdecl_grid import GrdeclGrid, GridRelative
+from xtgeo.grid3d.grid_properties import GridProperties, gridproperties_from_file
+from xtgeo.io._file import FileFormat, FileWrapper
+
+logger = null_logger(__name__)
+
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d.grid import Grid
+
+
+def import_ecl_egrid(
+    gfile: FileWrapper,
+    relative_to: GridRelative = GridRelative.MAP,
+    fileformat: FileFormat = FileFormat.EGRID,
+) -> dict[str, Any]:
+    egrid = EGrid.from_file(gfile.file, fileformat=fileformat)
+    result = grid_from_ecl_grid(egrid, relative_to=relative_to)
+
+    if egrid.egrid_head.file_head.rock_model == RockModel.DUAL_POROSITY:
+        result["dualporo"] = True
+        result["dualperm"] = False
+    elif egrid.egrid_head.file_head.rock_model == RockModel.DUAL_PERMEABILITY:
+        result["dualporo"] = True
+        result["dualperm"] = True
+
+    return result
+
+
+def import_ecl_run(
+    groot: str,
+    ecl_grid: Grid,
+    initprops: list[str] | None = None,
+    restartprops: list[str] | None = None,
+    restartdates: list[str] | None = None,
+) -> None:
+    """Import Eclipse run suite: EGrid and properties from INIT and UNRST.
+    For the INIT and UNRST files, property dates shall be selected."""
+    ecl_init = FileWrapper(f"{groot}.INIT")
+    ecl_rsta = FileWrapper(f"{groot}.UNRST")
+    grdprops = GridProperties()
+
+    # import the init properties unless list is empty
+    if initprops:
+        initprops_ = gridproperties_from_file(
+            ecl_init.name, names=initprops, fformat="init", dates=None, grid=ecl_grid
+        )
+        if initprops_.props:
+            grdprops.append_props(initprops_.props)
+
+    # import the restart properties for dates unless lists are empty
+    if restartprops and restartdates:
+        restartprops_ = gridproperties_from_file(
+            ecl_rsta.name,
+            names=restartprops,
+            fformat="unrst",
+            dates=restartdates,
+            grid=ecl_grid,
+        )
+        if restartprops_.props:
+            grdprops.append_props(restartprops_.props)
+    ecl_grid.gridprops = grdprops
+
+
+def import_ecl_grdecl(
+    gfile: FileWrapper, relative_to: GridRelative = GridRelative.MAP
+) -> dict[str, Any]:
+    """Import grdecl format."""
+    grdecl_grid = GrdeclGrid.from_file(gfile.file, fileformat=FileFormat.GRDECL)
+    return grid_from_ecl_grid(grdecl_grid, relative_to=relative_to)
+
+
+def import_ecl_bgrdecl(
+    gfile: FileWrapper, relative_to: GridRelative = GridRelative.MAP
+) -> dict[str, Any]:
+    """Import binary files with GRDECL layout."""
+    grdecl_grid = GrdeclGrid.from_file(gfile.file, fileformat=FileFormat.BGRDECL)
+    return grid_from_ecl_grid(grdecl_grid, relative_to=relative_to)
+
+
+def grid_from_ecl_grid(
+    ecl_grid: EGrid, relative_to: GridRelative = GridRelative.MAP
+) -> dict[str, Any]:
+    result = {}
+    result["coordsv"] = ecl_grid.xtgeo_coord(relative_to=relative_to)
+    result["zcornsv"] = ecl_grid.xtgeo_zcorn(relative_to=relative_to)
+    result["actnumsv"] = ecl_grid.xtgeo_actnum()
+    if relative_to == GridRelative.MAP and ecl_grid.map_axis_units is not None:
+        result["units"] = ecl_grid.map_axis_units
+    else:
+        result["units"] = ecl_grid.grid_units
+
+    return result

xtgeo/grid3d/_grid_import_roff.py

@@ -0,0 +1,135 @@
+"""Private module, Grid Import private functions for ROFF format."""
+
+from __future__ import annotations
+
+import pathlib
+import tempfile
+import warnings
+from contextlib import contextmanager
+from io import BufferedReader, BytesIO
+from typing import TYPE_CHECKING, Generator
+
+from xtgeo.common import null_logger
+
+from ._roff_grid import RoffGrid
+
+if TYPE_CHECKING:
+    from numpy.typing import NDArray
+
+    from xtgeo.common.types import FileLike
+    from xtgeo.io._file import FileWrapper
+
+
+logger = null_logger(__name__)
+
+
+def match_xtgeo_214_header(header: bytes) -> bool:
+    """
+    Check whether the start of a binary file matches
+    the problematic xtgeo version 2.14 contents.
+
+    Params:
+      header: the start of a file
+
+    """
+    first_part_match = header.startswith(
+        b"roff-bin\0"
+        b"#ROFF file#\0"
+        b"#Creator: CXTGeo subsystem of XTGeo by JCR#\0"
+        b"tag\0filedata\0"
+        b"int\0byteswaptest\0"
+    )
+    problem_area_match = header[99:].startswith(
+        b"char\0filetype\0grid\0char\0creationDate\0UNKNOWNendtag"
+    )
+    return first_part_match and problem_area_match
+
+
+def replace_xtgeo_214_header(header: bytes) -> bytes:
+    """
+    Given that match_xtgeo_214_header(header), inserts
+    a \0 in the correct place.
+    """
+    return header[:143] + b"\0" + header[143:]
+
+
+@contextmanager
+def handle_deprecated_xtgeo_roff_file(
+    filelike: FileLike,
+) -> Generator[
+    FileLike | tempfile._TemporaryFileWrapper[bytes],
+    None,
+    None,
+]:
+    """
+    A contextmanager that inplace fixes grid roff files
+    that were written by XTGeo prior to version 2.15. This
+    backwards compatibility should eventually be deprecated
+
+    Example::
+
+       with handle_deprecated_xtgeo_roff_file("grid.roff") as converted_grid:
+          roff_grid = RoffGrid.from_file(converted_file)
+
+
+    Before version 2.15, grids with _xtgformat=1 would be written with missing
+    '\\0' after the creationDate. However, it would also silently read that
+    file without any issues in the final product. roffio is less leanient when
+    it comes to the format it will accept and so does not recover. Luckily, the
+    creationDate was set to 'UNKNOWN' so we can be fairly certain we replace
+    correctly.
+
+    """
+    inhandle: FileLike | BufferedReader = filelike
+    close = False
+    if isinstance(filelike, (str, pathlib.Path)):
+        inhandle = open(filelike, "rb")  # noqa: SIM115
+        close = True
+
+    # MYPY is uanble to figur out that isinstance check
+    # above means we have an IO-based class now.
+    assert isinstance(inhandle, (BufferedReader, BytesIO))
+    goback = inhandle.tell()
+    header = inhandle.read(200)
+
+    if match_xtgeo_214_header(header):
+        name = "buffer"
+        if hasattr(filelike, "name"):
+            name = filelike.name
+        warnings.warn(
+            f"The roff file {name} contains nonstandard but harmless roff"
+            " format detail written by XTGeo version <=2.14. Reading of such files"
+            " is deprecated, consider re-exporting the file with XTGeo version >=2.15.3"
+        )
+
+        new_header = replace_xtgeo_214_header(header)
+
+        with tempfile.NamedTemporaryFile() as outhandle:
+            outhandle.write(new_header)
+            inhandle.seek(200)
+            outhandle.write(inhandle.read())
+            outhandle.seek(0)
+            yield outhandle
+            if close:
+                inhandle.close()
+            else:
+                inhandle.seek(goback)
+
+    else:
+        if close:
+            inhandle.close()
+        else:
+            inhandle.seek(goback)
+
+        yield filelike
+
+
+def import_roff(gfile: FileWrapper) -> dict[str, NDArray | dict[str, range] | None]:
+    with handle_deprecated_xtgeo_roff_file(gfile._file) as converted_file:
+        roff_grid = RoffGrid.from_file(converted_file)
+    return {
+        "actnumsv": roff_grid.xtgeo_actnum(),
+        "coordsv": roff_grid.xtgeo_coord(),
+        "zcornsv": roff_grid.xtgeo_zcorn(),
+        "subgrids": roff_grid.xtgeo_subgrids(),
+    }