xtgeo 4.14.0__cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl

xtgeo/grid3d/_ecl_inte_head.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+from typing import Any, Literal, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from xtgeo.common.log import null_logger
+
+from ._ecl_output_file import Phases, Simulator, TypeOfGrid, UnitSystem
+
+_logger = null_logger(__name__)
+
+
+class InteHead:
+    """Contains the values for the INTEHEAD array in ecl restart
+    and init files.
+
+    Output files from eclipse and opm flow will contain sections
+    starting with keyword-array headers. One of these is the INTEHEAD
+    keyword. The values in the array are integers, and the meaning
+    of each index is described in the e.g. the OPM user manual (2021-04 rev_01
+    section D.6-D.7).
+
+    The length of the array is not specified, meaning some values are missing,
+    the InteHead class creates a lookup for these values:
+
+    >>> intehead = InteHead(np.array([0,1,2,3,4,5,6,7,8]))
+    >>> intehead.num_x
+    8
+    >>> # The year field is missing in the input
+    >>> intehead.year is None
+    True
+    """
+
+    def __init__(self, values: npt.NDArray[np.int_]) -> None:
+        """Create an InteHead from the corresponding array.
+
+        Args:
+            values: Array of values following the INTEHEAD keyword
+                in an ECL restart or init file.
+        """
+        self.values = values
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, InteHead):
+            return False
+
+        return np.array_equal(self.values, other.values)
+
+    def __repr__(self) -> str:
+        return f"InteHead(values={self.values})"
+
+    def __str__(self) -> str:
+        return self.__repr__()
+
+    def _optional_index_lookup(self, index: int) -> int | None:
+        """Looks up the value at the given index, returning None if out of bound.
+
+        Args:
+            index: The index in the value array to look up
+            constructor: Constructor function to wrap non-None values in, defaults
+                to identity.
+        Returns:
+            value at the index, None if out of bounds.
+        """
+        return self.values[index] if len(self.values) > index else None
+
+    @property
+    def unit_system(self) -> UnitSystem | None:
+        """
+        The unit system used in the file.
+        """
+        v = self._optional_index_lookup(2)
+        return None if v is None else UnitSystem(v)
+
+    @property
+    def num_x(self) -> int | None:
+        """The number of columns (x direction) of cells"""
+        return self._optional_index_lookup(8)
+
+    @property
+    def num_y(self) -> int | None:
+        """The number of rows (y direction) of cells"""
+        return self._optional_index_lookup(9)
+
+    @property
+    def num_z(self) -> int | None:
+        """The number of layers (z direction) of cells"""
+        return self._optional_index_lookup(10)
+
+    @property
+    def num_active(self) -> int | None:
+        """The number of active cells"""
+        return self._optional_index_lookup(11)
+
+    @property
+    def phases(self) -> Phases | None:
+        """The phase system used for simulation"""
+        if any(ids in str(self.simulator) for ids in ["300", "INTERSECT"]):
+            # item 14 in E300 runs is number of tracers, not IPHS; assume oil/wat/gas
+            # item 14 in INTERSECT is always(?) undef., not IPHS; assume oil/wat/gas
+            return Phases.OIL_WATER_GAS
+        v = self._optional_index_lookup(14)
+        return None if v is None else Phases(v)
+
+    @property
+    def day(self) -> int | None:
+        """The simulated time calendar day
+
+        (e.g. 3rd of april 2018)
+
+        """
+        return self._optional_index_lookup(64)
+
+    @property
+    def month(self) -> int | None:
+        """The simulated time calendar month
+
+        4 for simulation being in month 4.
+
+        """
+        return self._optional_index_lookup(65)
+
+    @property
+    def year(self) -> int | None:
+        """The simulated time calendar month
+
+        e.g. 2018 for simulation being done in year 2018
+        """
+        return self._optional_index_lookup(66)
+
+    @property
+    def simulator(self) -> Simulator | int | None:
+        """The simulator used for producing the run, or integer code if unknown"""
+        s_code = self._optional_index_lookup(94)
+        try:
+            return Simulator(s_code)
+        except ValueError:
+            # changed from a UserWarning to a logging message
+            _logger.warning("Unknown simulator code %s", s_code)
+            return s_code
+
+    @property
+    def type_of_grid(self) -> TypeOfGrid | None:
+        """The type of grid used in the simulation"""
+        value = self._optional_index_lookup(13)
+        return (
+            None
+            if value is None
+            else TypeOfGrid.alternate_code(cast("Literal[0, 1, 2, 3]", value))
+        )

xtgeo/grid3d/_ecl_logi_head.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from ._ecl_output_file import Simulator
+
+
+def lookup_optional_code(values: list[bool], index: int) -> bool | None:
+    if len(values) <= index:
+        return None
+    return values[index]
+
+
+@dataclass
+class LogiHead:
+    """Contains the values for the LOGIHEAD array in restart and init files.
+
+    Output files from eclipse and opm flow will contain sections
+    starting with keyword-array headers. One of these is the LOGIHEAD
+    keyword. The values in the array are booleans, and the meaning
+    of each index is described in the e.g. the OPM user manual (2021-04 rev_01
+    section D.6-D.7).
+
+    The length of the array is not specified, meaning some values are missing,
+    the InteHead class creates a lookup for these values:
+
+    Generally, the field describe whether an option has been enabled in the
+    model, ie. if logihead.dual_porosity is True then the model uses the
+    dual porosity feature.
+
+    >>> logihead = LogiHead.from_file_values([True, True, False], Simulator.ECLIPSE_100)
+    >>> logihead.dissolved_gas
+    True
+    >>> # Whether coal bed methane is used is missing
+    >>> logihead.coal_bed_methane is None
+    True
+
+    """
+
+    dissolved_gas: bool | None = None
+    vaporized_oil: bool | None = None
+    directional: bool | None = None
+    radial: bool | None = None
+    reversible: bool | None = None
+    hysterisis: bool | None = None
+    dual_porosity: bool | None = None
+    end_point_scaling: bool | None = None
+    directional_end_point_scaling: bool | None = None
+    reversible_end_point_scaling: bool | None = None
+    alternate_end_point_scaling: bool | None = None
+    miscible_displacement: bool | None = None
+    scale_water_pressure1: bool | None = None
+    scale_water_pressure2: bool | None = None
+    coal_bed_methane: bool | None = None
+
+    @classmethod
+    def from_file_values(cls, values: list[bool], simulator: Simulator) -> LogiHead:
+        """Construct a LogiHead from the array following the LOGIHEAD keyword
+        Args:
+            values: The iterable of boolean values following the LOGIHEAD keyword
+            simulator: The meaning of each field is simulator dependent, so
+                the simulator must be given.
+        """
+        if simulator == Simulator.ECLIPSE_100:
+            # Weirdly, eclipse_100 outputs reversible and radial flags
+            # in swapped order.
+            indices = [0, 1, 2, 4, 3, 6, 14, 16, 17, 18, 19, 35, 55, 56, 127]
+        else:
+            indices = [0, 1, 2, 3, 4, 6, 14, 16, 17, 18, 19, 35, 55, 56, 127]
+
+        return cls(*[lookup_optional_code(values, i) for i in indices])

xtgeo/grid3d/_ecl_output_file.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from enum import Enum, unique
+from typing import Literal
+
+
+@unique
+class TypeOfGrid(Enum):
+    """
+    A Grid has three possible data layout formats, UNSTRUCTURED, CORNER_POINT,
+    BLOCK_CENTER and COMPOSITE (meaning combination of the two former). Only
+    CORNER_POINT layout is supported by XTGeo.
+    """
+
+    COMPOSITE = 0
+    CORNER_POINT = 1
+    UNSTRUCTURED = 2
+    BLOCK_CENTER = 3
+
+    @classmethod
+    def alternate_code(cls, code: Literal[0, 1, 2, 3]) -> TypeOfGrid:
+        """Converts from alternate code to TypeOfGrid member.
+
+        weirdly, type of grid sometimes (For instance init's INTHEAD and
+        FILEHEAD) have an alternate integer code for type of grid.
+        """
+        if code == 0:
+            type_of_grid = cls.CORNER_POINT
+        elif code == 1:
+            type_of_grid = cls.UNSTRUCTURED
+        elif code == 2:
+            type_of_grid = cls.COMPOSITE
+        elif code == 3:
+            type_of_grid = cls.BLOCK_CENTER
+        else:
+            raise ValueError(f"Unknown grid type {code}")
+        return type_of_grid
+
+    @property
+    def alternate_value(self) -> int:
+        """Inverse of alternate_code."""
+        alternate_value = 0
+        if self == TypeOfGrid.CORNER_POINT:
+            alternate_value = 0
+        elif self == TypeOfGrid.UNSTRUCTURED:
+            alternate_value = 1
+        elif self == TypeOfGrid.COMPOSITE:
+            alternate_value = 2
+        elif self == TypeOfGrid.BLOCK_CENTER:
+            alternate_value = 3
+        else:
+            raise ValueError(f"Unknown grid type {self}")
+        return alternate_value
+
+
+@unique
+class UnitSystem(Enum):
+    METRIC = 1
+    FIELD = 2
+    LAB = 3
+
+
+@unique
+class Phases(Enum):
+    E300_GENERIC = 0
+    OIL = 1
+    WATER = 2
+    OIL_WATER = 3
+    GAS = 4
+    OIL_GAS = 5
+    GAS_WATER = 6
+    OIL_WATER_GAS = 7
+
+
+@unique
+class Simulator(Enum):
+    ECLIPSE_100 = 100
+    ECLIPSE_300 = 300
+    ECLIPSE_300_THERMAL = 500
+    INTERSECT = 700
+    FRONTSIM = 800