xtgeo 4.12.1__cp313-cp313-win_amd64.whl → 4.13.1__cp313-cp313-win_amd64.whl

xtgeo/grid3d/_grid_translate_coords.py

@@ -0,0 +1,154 @@
+"""Private module for translating coordiantes plus flipping and rotation."""
+
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from xtgeo.grid3d import Grid
+
+
+def _rotate_grid3d(
+    new_grd: Grid, add_rotation: float, rotation_xy: tuple[float, float] | None = None
+) -> None:
+    """Rotate the grid around the cell 1,1,1 corner, or some other coordinate."""
+
+    # Convert angle to radians
+    angle_rad = math.radians(add_rotation)
+
+    # Create rotation matrix coefficients
+    cos_theta = math.cos(angle_rad)
+    sin_theta = math.sin(angle_rad)
+
+    # extract
+    coord_array = new_grd._coordsv.copy()
+    rotated_coords = coord_array.copy()
+
+    if rotation_xy is None:
+        x0, y0, _ = new_grd._coordsv[0, 0, :3]
+    else:
+        x0, y0 = rotation_xy
+
+    x_coords = coord_array[:, :, [0, 3]].copy()  # x1 and x2
+    y_coords = coord_array[:, :, [1, 4]].copy()  # y1 and y2
+
+    # Translate to origin
+    x_translated = x_coords - x0
+    y_translated = y_coords - y0
+
+    # Rotate using rotation matrix
+    x_rotated = x_translated * cos_theta - y_translated * sin_theta
+    y_rotated = x_translated * sin_theta + y_translated * cos_theta
+
+    # Translate back and assign
+    rotated_coords[:, :, [0, 3]] = x_rotated + x0
+    rotated_coords[:, :, [1, 4]] = y_rotated + y0
+
+    # Z coordinates remain unchanged (indices 2 and 5)
+    new_grd._coordsv = rotated_coords.copy()
+
+
+def _flip_vertically(grid: Grid) -> None:
+    """Flip the grid vertically."""
+
+    # find average depth of corners
+    avg_z = grid._zcornsv.mean()
+
+    grid._zcornsv = grid._zcornsv[:, :, ::-1, :]
+    grid._zcornsv *= -1
+
+    # find the new average and compute the difference for shifting
+    new_avg_z = grid._zcornsv.mean()
+    diff = avg_z - new_avg_z
+    grid._zcornsv += diff
+
+    grid._actnumsv = np.flip(grid._actnumsv, axis=2).copy()
+
+    # Handle properties if they exist
+    if grid._props and grid._props.props:
+        for prop in grid._props.props:
+            prop.values = np.flip(prop.values, axis=2).copy()
+
+    # When we flip the grid, the subgrid info must also be flipped
+    subgrids = grid.get_subgrids()
+    if subgrids:
+        reverted = dict(reversed(subgrids.items()))
+        grid.set_subgrids(reverted)
+
+    if grid._ijk_handedness == "left":
+        grid._ijk_handedness = "right"
+    else:
+        grid._ijk_handedness = "left"
+
+
+def _translate_geometry(grid: Grid, translate: tuple[float, float, float]) -> None:
+    grid._coordsv[:, :, 0] += translate[0]
+    grid._coordsv[:, :, 1] += translate[1]
+    grid._coordsv[:, :, 2] += translate[2]
+    grid._coordsv[:, :, 3] += translate[0]
+    grid._coordsv[:, :, 4] += translate[1]
+    grid._coordsv[:, :, 5] += translate[2]
+
+    grid._zcornsv += translate[2]
+
+
+def _transfer_to_target(grid: Grid, target: tuple[float, float, float]) -> None:
+    # get the coordinates for the active cells
+    x, y, z = grid.get_xyz(asmasked=True)
+
+    # set the grid center to the desired target coordinates
+    shift_x = target[0] - x.values.mean()
+    shift_y = target[1] - y.values.mean()
+    shift_z = target[2] - z.values.mean()
+
+    _translate_geometry(grid, (shift_x, shift_y, shift_z))
+
+
+def translate_coordinates(
+    self: Grid,
+    translate: tuple[float, float, float] = (0.0, 0.0, 0.0),
+    flip: tuple[int, int, int] = (1, 1, 1),
+    add_rotation: float = 0.0,
+    rotation_point: tuple[float, float] | None = None,
+    target_coordinates: tuple[float, float, float] | None = None,
+) -> None:
+    """Rotate, flip grid and translate grid coordinates.
+
+    This should be done in a sequence like this
+    1) Add rotation (with value ``add_rotation``) to rotate the grid counter-clockwise
+    2) Flip the grid
+    3a) translate the grid by adding (x, y, z), OR
+    3b) set a target location the grid centre.
+
+    """
+    self._set_xtgformat2()
+
+    if abs(add_rotation) > 1e-10:  # Skip rotation if angle is essentially zero
+        _rotate_grid3d(self, add_rotation, rotation_xy=rotation_point)
+
+    if flip[2] == -1:
+        _flip_vertically(self)
+
+    if flip[0] == -1:
+        self.reverse_column_axis()
+
+    if flip[1] == -1:
+        self.reverse_row_axis()
+
+    use_translate = False
+    if not all(abs(x) < 1e-10 for x in translate):
+        _translate_geometry(self, translate)
+        use_translate = True
+
+    if target_coordinates and use_translate:
+        raise ValueError(
+            "Using both key 'translate' and key 'target_coordinates' is not allowed. "
+            "Use either."
+        )
+
+    if target_coordinates:
+        # transfer the grid's geometrical centre to a given location
+        _transfer_to_target(self, target_coordinates)

xtgeo/grid3d/_gridprop_roxapi.py

@@ -150,12 +150,18 @@ def _validate_dtype_in_roxar(
         )
 
     try:
+        # for mypy
+        min_val: int | float
+        max_val: int | float
+
         if np.issubdtype(dtype, np.integer):
             # Integer type
-            min_val, max_val = np.iinfo(dtype).min, np.iinfo(dtype).max
+            min_val = int(np.iinfo(dtype).min)
+            max_val = int(np.iinfo(dtype).max)
         elif np.issubdtype(dtype, np.floating):
             # Float type
-            min_val, max_val = np.finfo(dtype).min, np.finfo(dtype).max
+            min_val = float(np.finfo(dtype).min)
+            max_val = float(np.finfo(dtype).max)
         else:
             # Unknown type
             raise RuntimeError("Probable bug, values array not integer or float")

xtgeo/grid3d/grid.py

@@ -28,6 +28,7 @@ from . import (
     _grid_import_ecl,
     _grid_refine,
     _grid_roxapi,
+    _grid_translate_coords,
     _grid_wellzone,
     _gridprop_lowlevel,
 )
@@ -1818,7 +1819,9 @@ class Grid(_Grid3D):
             name (str): name of property
             flip (bool): Use False for Petrel grids were Z is negative down
                 (experimental)
-            asmasked (bool): True if only for active cells, False for all cells
+            asmasked (bool): True if only for active cells, False for all cells.
+                With `False` the inactive cells are included, but the numpy
+                array is still a MaskedArray instance.
             metric (str): One of the following metrics:
                 * "euclid": sqrt(dx^2 + dy^2 + dz^2)
                 * "horizontal": sqrt(dx^2 + dy^2)
@@ -1854,7 +1857,8 @@ class Grid(_Grid3D):
         Args:
             name (str): names of properties
             asmasked (bool). If True, make a np.ma array where inactive cells
-                are masked.
+                are masked. Otherwise the inactive cells are included, but the numpy
+                array is still a MaskedArray instance.
             metric (str): One of the following metrics:
                 * "euclid": sqrt(dx^2 + dy^2 + dz^2)
                 * "horizontal": sqrt(dx^2 + dy^2)
@@ -1884,7 +1888,8 @@ class Grid(_Grid3D):
         Args:
             name (str): names of properties
             asmasked (bool). If True, make a np.ma array where inactive cells
-                are masked.
+                are masked. Otherwise the inactive cells are included, but the numpy
+                array is still a MaskedArray instance.
             metric (str): One of the following metrics:
                 * "euclid": sqrt(dx^2 + dy^2 + dz^2)
                 * "horizontal": sqrt(dx^2 + dy^2)
@@ -2476,21 +2481,48 @@ class Grid(_Grid3D):
     def translate_coordinates(
         self,
         translate: tuple[float, float, float] = (0.0, 0.0, 0.0),
+        target_coordinates: tuple[float, float, float] | None = None,
         flip: tuple[int, int, int] = (1, 1, 1),
-    ) -> None:
-        """Translate (move) and/or flip grid coordinates in 3D.
+        add_rotation: float = 0.0,
+        rotation_point: tuple[float, float] | None = None,
+    ) -> Grid | None:
+        """Translate (move), flip and rotate the 3D grid geometry.
 
-        By 'flip' here, it means that the full coordinate array are multiplied
-        with -1.
+        By 'flip' here, it means that the full coordinate arrays are inverted.
 
         Args:
-            translate (tuple): Translation distance in X, Y, Z coordinates
-            flip (tuple): Flip array. The flip values must be 1 or -1.
+            translate: Translation distance in X, Y, Z coordinates; these
+                values will be added to the current coordinates.
+            target_coordinates: Position for the centerpoint of the active grid cells.
+                Note that key ``translate`` cannot be used with this key; i.e. use
+                either ``translate`` or ``target_coordinates``
+            flip: Flip array. The flip values must be 1 or -1, meaning 1 for
+                keeping the current, and -1 for activating an axis flip.
+            add_rotation: The grid geometry will get an additional rotation by this
+                value, in degrees and counter clock wise.
+            rotation_point: Which (x, y) coordiate to be set as origin when adding
+                rotation. Default is the corner of the first cell number.
+
+        Note:
+            Grid properties attached to the grid will also be transformed
+
+        Example::
+            import xtgeo
+            grd = xtgeo.grid_from_roxar(project, "simpleb8")
+            poro = xtgeo.gridproperty_from_roxar(project, "simpleb8", "PORO")
+            grd.props = [poro]
+
+            grd.translate_coordinates(translate=(10,10, 20), flip=(1,1,-1),
+                add_rotation=30)
+
+            grd.to_roxar(project, "simpleb8_translated")
+            poro1 = grd.get_prop_by_name("PORO")
+            poro1.to_roxar(project, "simpleb8_translated", "PORO")
 
-        Raises:
-            RuntimeError: If translation goes wrong for unknown reasons
         """
-        _grid_etc1.translate_coordinates(self, translate=translate, flip=flip)
+        _grid_translate_coords.translate_coordinates(
+            self, translate, flip, add_rotation, rotation_point, target_coordinates
+        )
 
     def reverse_row_axis(
         self, ijk_handedness: Literal["left", "right"] | None = None
@@ -2498,7 +2530,7 @@ class Grid(_Grid3D):
         """Reverse the row axis (J indices).
 
         This means that IJK system will switched between a left vs right handed system.
-        It is here (by using ijk_handedness key), possible to set a wanted stated.
+        It is here (by using ijk_handedness key), possible to set a wanted handedness.
 
         Note that properties that are assosiated with the grid (through the
         :py:attr:`~gridprops` or :py:attr:`~props` attribute) will also be
@@ -2524,6 +2556,38 @@ class Grid(_Grid3D):
         """
         _grid_etc1.reverse_row_axis(self, ijk_handedness=ijk_handedness)
 
+    def reverse_column_axis(
+        self, ijk_handedness: Literal["left", "right"] | None = None
+    ) -> None:
+        """Reverse the column axis (I indices).
+
+        This means that IJK system will switched between a left vs right handed system.
+        It is here (by using ijk_handedness key), possible to set a wanted handedness.
+
+        Note that properties that are assosiated with the grid (through the
+        :py:attr:`~gridprops` or :py:attr:`~props` attribute) will also be
+        reversed (which is desirable).
+
+        Args:
+            ijk_handedness (str): If set to "right" or "left", do only reverse columns
+                if handedness is not already achieved.
+
+        Example::
+
+            grd = xtgeo.grid_from_file("somefile.roff")
+            prop1 = xtgeo.gridproperty_from_file("somepropfile1.roff")
+            prop2 = xtgeo.gridproperty_from_file("somepropfile2.roff")
+
+            grd.props = [prop1, prop2]
+
+            # secure that the grid geometry is IJK right-handed
+            grd.reverse_column_axis(ijk_handedness="right")
+
+        .. versionadded:: 4.14
+
+        """
+        _grid_etc1.reverse_column_axis(self, ijk_handedness=ijk_handedness)
+
     def make_zconsistent(self, zsep: float | int = 1e-5) -> None:
         """Make the 3D grid consistent in Z, by a minimal gap (zsep).
 
@@ -2556,11 +2620,13 @@ class Grid(_Grid3D):
            :align: center
 
         Args:
-            nhdiv (int): Number of hybrid layers.
-            toplevel (float): Top of hybrid grid.
-            bottomlevel (float): Base of hybrid grid.
-            region (GridProperty, optional): Region property (if needed).
-            region_number (int): Which region to apply hybrid grid in if region.
+            nhdiv: Number of hybrid layers.
+            toplevel: Top of hybrid grid.
+            bottomlevel: Base of hybrid grid.
+            region: Region property (if needed). Note that the region will only be
+                applied in a lateral sense: i.e. if a column is in the region, then
+                the full column will be converted to hybrid.
+            region_number: Which region to apply hybrid grid in if region.
 
         Example:
             Create a hybridgrid from file, based on a GRDECL file (no region)::
@@ -2577,6 +2643,7 @@ class Grid(_Grid3D):
         .. _usage in the Troll field: https://doi.org/10.2118/148023-MS
 
         """
+
         _grid_hybrid.make_hybridgrid(
             self,
             nhdiv=nhdiv,

xtgeo/io/_file.py

@@ -227,7 +227,7 @@ class FileWrapper:
             date = obj.metadata.opt.datetime  # type: ignore
             newname = short + "--" + desc
             if date:
-                newname += "--" + date
+                newname += "--" + str(date)
         else:
             # return without modifications of self._file to avoid with_suffix() issues
             # if the file name stem itself contains multiple '.'

xtgeo/metadata/metadata.py

@@ -21,6 +21,12 @@ from xtgeo.common.log import null_logger
 if TYPE_CHECKING:
     from datetime import datetime
 
+    from xtgeo.cube.cube1 import Cube
+    from xtgeo.grid3d.grid import Grid, GridProperty
+    from xtgeo.surface.regular_surface import RegularSurface
+    from xtgeo.well.well1 import Well
+
+
 logger = null_logger(__name__)
 
 
@@ -56,11 +62,11 @@ class _OptionalMetaData:
     def __init__(self) -> None:
         self._name = "A Longer Descriptive Name e.g. from SMDA"
         self._shortname = "TheShortName"
-        self._datatype = None
+        self._datatype: str | None = None
         self._md5sum: str | None = None
         self._description = "Some description"
         self._crs = None
-        self._datetime: datetime | None = None
+        self._datetime: datetime | str | None = None
         self._deltadatetime = None
         self._visuals = {"colortable": "rainbow", "lower": None, "upper": None}
         self._domain = "depth"
@@ -84,11 +90,11 @@ class _OptionalMetaData:
         self._name = newname
 
     @property
-    def datetime(self) -> datetime | None:
+    def datetime(self) -> datetime | str | None:
         return self._datetime
 
     @datetime.setter
-    def datetime(self, newdate: datetime) -> None:
+    def datetime(self, newdate: datetime | str) -> None:
         # TODO: validation
         self._datetime = newdate
 
@@ -147,15 +153,15 @@ class _OptionalMetaData:
 class MetaData:
     """Generic metadata class, not intended to be used directly."""
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Generic metadata class __init__, not be used directly."""
-        self._required = {}
+        self._required: dict[str, Any] = {}
         self._optional = _OptionalMetaData()
         self._freeform = {}
 
         self._freeform = {"smda": "whatever"}
 
-    def get_metadata(self):
+    def get_metadata(self) -> dict[str, Any]:
         """Get all metadata that are present."""
         allmeta = {}
         allmeta["_required_"] = self._required
@@ -164,7 +170,7 @@ class MetaData:
         return allmeta
 
     @property
-    def optional(self):
+    def optional(self) -> dict[str, Any]:
         """Return or set optional metadata.
 
         When setting optional names, it can be done in several ways...
@@ -176,7 +182,7 @@ class MetaData:
         return self._optional.get_meta()
 
     @optional.setter
-    def optional(self, indict):
+    def optional(self, indict: dict[str, Any]) -> None:
         # setting the optional key, including validation
         if not isinstance(indict, dict):
             raise ValueError(f"Input must be a dictionary, not a {type(indict)}")
@@ -185,7 +191,7 @@ class MetaData:
             setattr(self._optional, "_" + key, value)
 
     @property
-    def opt(self):
+    def opt(self) -> _OptionalMetaData:
         """Return the metadata optional instance.
 
         This makes access to the _OptionalMetaData instance.
@@ -198,26 +204,17 @@ class MetaData:
         """
         return self._optional
 
-    @optional.setter
-    def optional(self, indict):
-        # setting the optional key, including validation
-        if not isinstance(indict, dict):
-            raise ValueError(f"Input must be a dictionary, not a {type(indict)}")
-
-        for key, value in indict.items():
-            setattr(self._optional, "_" + key, value)
-
     @property
-    def freeform(self):
+    def freeform(self) -> dict[str, Any]:
         """Get or set the current freeform metadata dictionary."""
         return self._freeform
 
     @freeform.setter
-    def freeform(self, adict):
+    def freeform(self, adict: dict[str, Any]) -> None:
         """Freeform is a whatever you want set, without any validation."""
         self._freeform = adict.copy()
 
-    def generate_fmu_name(self):
+    def generate_fmu_name(self) -> str:
         """Generate FMU name on form xxxx--yyyy--date but no suffix."""
         fname = ""
         first = "prefix"
@@ -233,7 +230,7 @@ class MetaData:
 class MetaDataRegularSurface(MetaData):
     """Metadata for RegularSurface() objects."""
 
-    REQUIRED = {
+    REQUIRED: dict[str, Any] = {
         "ncol": 1,
         "nrow": 1,
         "xori": 0.0,
@@ -245,20 +242,20 @@ class MetaDataRegularSurface(MetaData):
         "undef": UNDEF,
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Docstring."""
         super().__init__()
-        self._required = __class__.REQUIRED
+        self._required = self.REQUIRED
         self._optional._datatype = "Regular Surface"
 
     @property
-    def required(self):
+    def required(self) -> dict[str, Any]:
         """Get of set required metadata."""
         return self._required
 
     @required.setter
-    def required(self, obj):
-        if not isinstance(obj, xtgeo.RegularSurface):
+    def required(self, obj: RegularSurface) -> None:
+        if not isinstance(obj, xtgeo.RegularSurface):  # type: ignore[attr-defined]
             raise ValueError("Input object is not a RegularSurface()")
 
         self._required["ncol"] = obj.ncol
@@ -276,7 +273,7 @@ class MetaDataRegularCube(MetaData):
     """Metadata for Cube() objects."""
 
     # allowed optional keys; these are set to avoid discussions
-    REQUIRED = {
+    REQUIRED: dict[str, Any] = {
         "ncol": 1,
         "nrow": 1,
         "nlay": 1,
@@ -292,20 +289,20 @@ class MetaDataRegularCube(MetaData):
         "undef": UNDEF,
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Docstring."""
         super().__init__()
-        self._required = __class__.REQUIRED
+        self._required = self.REQUIRED
         self._optional._datatype = "Regular Cube"
 
     @property
-    def required(self):
+    def required(self) -> dict[str, Any]:
         """Get of set required metadata."""
         return self._required
 
     @required.setter
-    def required(self, obj):
-        if not isinstance(obj, xtgeo.Cube):
+    def required(self, obj: Cube) -> None:
+        if not isinstance(obj, xtgeo.Cube):  # type: ignore[attr-defined]
             raise ValueError("Input object is not a regular Cube()")
 
         self._required["ncol"] = obj.ncol
@@ -326,7 +323,7 @@ class MetaDataRegularCube(MetaData):
 class MetaDataCPGeometry(MetaData):
     """Metadata for Grid() objects of type simplified CornerPoint Geometry."""
 
-    REQUIRED = {
+    REQUIRED: dict[str, Any] = {
         "ncol": 1,
         "nrow": 1,
         "nlay": 1,
@@ -338,20 +335,20 @@ class MetaDataCPGeometry(MetaData):
         "zscale": 1.0,
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Docstring."""
         super().__init__()
-        self._required = __class__.REQUIRED
+        self._required = self.REQUIRED
         self._optional._datatype = "CornerPoint GridGeometry"
 
     @property
-    def required(self):
+    def required(self) -> dict[str, Any]:
         """Get of set required metadata."""
         return self._required
 
     @required.setter
-    def required(self, obj):
-        if not isinstance(obj, xtgeo.Grid):
+    def required(self, obj: Grid) -> None:
+        if not isinstance(obj, xtgeo.Grid):  # type: ignore[attr-defined]
             raise ValueError("Input object is not a Grid()")
 
         self._required["ncol"] = obj.ncol
@@ -369,7 +366,7 @@ class MetaDataCPGeometry(MetaData):
 class MetaDataCPProperty(MetaData):
     """Metadata for GridProperty() objects belonging to CPGeometry."""
 
-    REQUIRED = {
+    REQUIRED: dict[str, Any] = {
         "ncol": 1,
         "nrow": 1,
         "nlay": 1,
@@ -377,20 +374,20 @@ class MetaDataCPProperty(MetaData):
         "discrete": False,
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Docstring."""
         super().__init__()
-        self._required = __class__.REQUIRED
+        self._required = self.REQUIRED
         self._optional._datatype = "CornerPoint GridProperty"
 
     @property
-    def required(self):
+    def required(self) -> dict[str, Any]:
         """Get of set required metadata."""
         return self._required
 
     @required.setter
-    def required(self, obj):
-        if not isinstance(obj, xtgeo.GridProperty):
+    def required(self, obj: GridProperty) -> None:
+        if not isinstance(obj, xtgeo.GridProperty):  # type: ignore[attr-defined]
             raise ValueError("Input object is not a GridProperty()")
 
         self._required["ncol"] = obj.ncol
@@ -403,7 +400,7 @@ class MetaDataCPProperty(MetaData):
 class MetaDataWell(MetaData):
     """Metadata for single Well() objects."""
 
-    REQUIRED = {
+    REQUIRED: dict[str, Any] = {
         "rkb": 0.0,
         "xpos": 0.0,
         "ypos": 0.0,
@@ -413,20 +410,20 @@ class MetaDataWell(MetaData):
         "zonelogname": None,
     }
 
-    def __init__(self):
+    def __init__(self) -> None:
         """Initialisation for Well metadata."""
         super().__init__()
-        self._required = __class__.REQUIRED
+        self._required = self.REQUIRED
         self._optional._datatype = "Well"
 
     @property
-    def required(self):
+    def required(self) -> dict[str, Any]:
         """Get of set required metadata."""
         return self._required
 
     @required.setter
-    def required(self, obj):
-        if not isinstance(obj, xtgeo.Well):
+    def required(self, obj: Well) -> None:
+        if not isinstance(obj, xtgeo.Well):  # type: ignore[attr-defined]
             raise ValueError("Input object is not a Well() instance!")
 
         self._required["rkb"] = obj.rkb