grid-apps 0.1.0b2__py3-none-any.whl

grid_apps/__init__.py

@@ -0,0 +1,37 @@
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+#  Copyright (c) 2022-2025 Mira Geoscience Ltd.                                     '
+#                                                                                   '
+#  This file is part of grid-apps package.                                          '
+#                                                                                   '
+#  grid-apps is distributed under the terms and conditions of the MIT License       '
+#  (see LICENSE file at the root of this source code package).                      '
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+
+
+try:
+    from ._version import __version__
+except ModuleNotFoundError:
+    from datetime import datetime
+
+    __date_str = datetime.today().strftime("%Y%m%d")
+    __version__ = "0.0.0.dev0+" + __date_str
+
+
+logging.basicConfig(level=logging.INFO)
+
+
+def assets_path() -> Path:
+    """Return the path to the assets folder."""
+
+    parent = Path(__file__).parent
+    folder_name = f"{parent.name}-assets"
+    assets_folder = parent.parent / folder_name
+    if not assets_folder.is_dir():
+        raise RuntimeError(f"Assets folder not found: {assets_folder}")
+
+    return assets_folder

grid_apps/_version.py

@@ -0,0 +1,2 @@
+# Version placeholder that will be replaced during substitution
+__version__ = "0.1.0b2"

grid_apps/block_model_to_octree/__init__.py

@@ -0,0 +1,8 @@
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+#  Copyright (c) 2024-2025 Mira Geoscience Ltd.                                     '
+#                                                                                   '
+#  This file is part of grid-apps package.                                          '
+#                                                                                   '
+#  grid-apps is distributed under the terms and conditions of the MIT License       '
+#  (see LICENSE file at the root of this source code package).                      '
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

grid_apps/block_model_to_octree/driver.py

@@ -0,0 +1,234 @@
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+#  Copyright (c) 2024-2025 Mira Geoscience Ltd.                                     '
+#                                                                                   '
+#  This file is part of grid-apps package.                                          '
+#                                                                                   '
+#  grid-apps is distributed under the terms and conditions of the MIT License       '
+#  (see LICENSE file at the root of this source code package).                      '
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+
+import numpy as np
+from discretize import TreeMesh
+from geoh5py.data import FloatData, ReferencedData
+from geoh5py.objects import BlockModel, Octree
+from geoh5py.ui_json.utils import fetch_active_workspace
+from scipy.spatial import cKDTree
+
+from grid_apps.block_model_to_octree.options import BlockModel2OctreeOptions
+from grid_apps.driver import BaseGridDriver
+from grid_apps.utils import (
+    block_model_to_discretize,
+    boundary_value_indices,
+    tensor_mesh_ordering,
+    treemesh_2_octree,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+class Driver(BaseGridDriver):
+    """
+    Convert a BlockModel object to Octree with various refinement strategies.
+    """
+
+    _params_class = BlockModel2OctreeOptions
+
+    @staticmethod
+    def block_model_to_treemesh(
+        entity: BlockModel, diagonal_balance=True, finalize=True
+    ) -> TreeMesh:
+        """
+        Convert a block model to an octree mesh with the same base cell size and
+        centered.
+
+        :param entity: BlockModel object to be converted
+        :param diagonal_balance: Whether to balance the mesh diagonally.
+        :param finalize: Whether to finalize the treemesh after creation.
+
+        :return: TreeMesh object.
+        """
+        origin = []
+        octree_cells = []
+        for ii, ax in zip("xyz", "uvz", strict=True):
+            cell_sizes = np.abs(getattr(entity, f"{ax}_cells"))
+            h_core = cell_sizes.min()
+
+            # Compute number of octree cells to span the extent
+            n_c = np.ceil(np.log2(np.sum(cell_sizes) / h_core))
+            cell_sizes_octree = np.ones(int(2**n_c)) * h_core
+            octree_cells.append(cell_sizes_octree)
+
+            # Colocate the center of the octree with the center of the block model
+            ind_core = np.where(cell_sizes == h_core)[0]
+            center = (
+                entity.origin[ii]
+                + entity.local_axis_centers(ax)[ind_core[len(ind_core) // 2]]
+            )
+
+            axis_center = len(cell_sizes_octree) // 2
+            origin.append(center - np.sum(cell_sizes_octree[:axis_center]) - h_core / 2)
+
+        treemesh = TreeMesh(
+            octree_cells,
+            x0=origin,
+            finalize=finalize,
+            diagonal_balance=diagonal_balance,
+        )
+
+        return treemesh
+
+    def make_grid(self) -> Octree:
+        """
+        Convert the block model and output the octree mesh.
+
+        :return: Octree object refined by the cell volumes or gradient of the data.
+        """
+        with fetch_active_workspace(self.params.geoh5, mode="r+"):
+            entity = self.params.entity
+
+            treemesh = Driver.block_model_to_treemesh(entity, finalize=False)
+            model = None
+            if self.params.data is None:
+                treemesh = Driver.refine_by_cell_volumes(
+                    treemesh, entity, finalize=True
+                )
+            else:
+                treemesh = Driver.refine_by_values(
+                    treemesh, self.params.data, finalize=True
+                )
+                # Transfer the model
+                ind = treemesh.get_containing_cells(entity.centroids)
+                model = (
+                    np.ones(treemesh.n_cells, dtype=self.params.data.values.dtype)
+                    * self.params.data.nan_value
+                )
+                model[ind] = self.params.data.values
+
+                nan_vals = (model == self.params.data.nan_value) | np.isnan(model)
+                if np.any(nan_vals):
+                    tree = cKDTree(entity.centroids)
+                    ind = tree.query(treemesh.cell_centers[nan_vals])[1]
+                    model[nan_vals] = self.params.data.values[ind]
+
+            octree = treemesh_2_octree(
+                self.params.geoh5,
+                treemesh,
+                parent=self.params.output.out_group,
+                name=self.params.output.export_as or entity.name + "_octree",
+            )
+
+            if model is not None and self.params.data is not None:
+                octree.add_data(
+                    {
+                        self.params.data.name: {
+                            "values": model,
+                            "entity_type": self.params.data.entity_type,
+                        }
+                    }
+                )
+
+            return octree
+
+    @staticmethod
+    def refine_by_cell_volumes(
+        mesh: TreeMesh,
+        entity: BlockModel,
+        finalize: bool = True,
+        mask: np.ndarray | None = None,
+    ) -> TreeMesh:
+        """
+        Refine the octree mesh by the cell volumes of the block model.
+
+        :param mesh: TreeMesh object to be refined.
+        :param entity: BlockModel object to be used for refinement.
+        :param finalize: Whether to finalize the treemesh after refinement.
+        :param mask: Optional mask on the block model centroids to apply the refinement over.
+
+        :return: TreeMesh object with refined levels.
+        """
+        if not isinstance(entity, BlockModel):
+            raise TypeError("entity must be an instance of BlockModel.")
+
+        tensor_oct_level = []
+        for ax in "uvz":
+            cell_sizes = np.abs(getattr(entity, f"{ax}_cells"))
+            h_core = cell_sizes.min()
+            # Find the core region
+            tensor_oct_level.append(np.log2(cell_sizes / h_core).astype(int))
+
+        e_x, e_y, e_z = np.meshgrid(*tensor_oct_level)
+        max_level = np.c_[np.ravel(e_x), np.ravel(e_y), np.ravel(e_z)].max(axis=1)
+
+        locations = entity.centroids
+        if mask is not None:
+            locations = locations[mask]
+            max_level = max_level[mask]
+
+        mesh.insert_cells(locations, mesh.max_level - max_level, finalize=finalize)
+
+        return mesh
+
+    @staticmethod
+    def refine_by_values(
+        mesh: TreeMesh, data: FloatData | ReferencedData, finalize=True
+    ) -> TreeMesh:
+        """
+        Increase the mesh resolution based on the gradient of data values.
+
+        :param mesh: Input TreeMesh object.
+        :param data: FloatData or ReferencedData object containing the values to
+            be used for refinement.
+        :param finalize: Whether to finalize the treemesh after refinement.
+
+        :return: TreeMesh object with refined levels.
+        """
+        if not isinstance(data, FloatData | ReferencedData):
+            raise TypeError(
+                "Argument 'data' must be an instance of FloatData or ReferencedData."
+            )
+
+        entity = data.parent
+        if not isinstance(entity, BlockModel):
+            raise TypeError("The parent of 'data' must be an instance of BlockModel.")
+
+        tensor = block_model_to_discretize(entity)
+        indices = tensor_mesh_ordering(entity)
+
+        gradients = np.abs(tensor.cell_gradient @ data.values[indices])
+        levels = np.zeros(gradients.shape, dtype=int)
+        isnan = np.isnan(gradients)
+
+        if isinstance(data, FloatData):
+            actives = gradients[~isnan]
+            bins = np.percentile(
+                actives[actives > 0], np.linspace(5, 95, mesh.max_level)
+            )
+            levels[~isnan] = np.searchsorted(bins, actives)
+        else:
+            levels[gradients > 0] = mesh.max_level
+
+        # Refine on the value/nan interface, without boundary cells
+        if any(isnan):
+            horizon = boundary_value_indices(
+                tensor, data.values[indices], data.nan_value
+            )
+            mesh = Driver.refine_by_cell_volumes(
+                mesh, entity, finalize=False, mask=horizon[np.argsort(indices)]
+            )
+
+        locs = tensor.average_cell_to_face @ tensor.cell_centers
+        mesh.insert_cells(locs[~isnan], levels[~isnan].astype(int), finalize=finalize)
+
+        return mesh
+
+
+if __name__ == "__main__":
+    file = Path(sys.argv[1]).resolve()
+    Driver.start(file)

grid_apps/block_model_to_octree/options.py

@@ -0,0 +1,60 @@
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+#  Copyright (c) 2024-2025 Mira Geoscience Ltd.                                     '
+#                                                                                   '
+#  This file is part of grid-apps package.                                          '
+#                                                                                   '
+#  grid-apps is distributed under the terms and conditions of the MIT License       '
+#  (see LICENSE file at the root of this source code package).                      '
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import ClassVar
+
+from geoapps_utils.driver.data import BaseData
+from geoh5py.data import FloatData, ReferencedData
+from geoh5py.groups import UIJsonGroup
+from geoh5py.objects import BlockModel
+from pydantic import BaseModel, ConfigDict
+
+from grid_apps import assets_path
+
+
+class OutputOptions(BaseModel):
+    """
+    Output parameters for block model creation.
+
+    :param export_as: Name of the output entity.
+    :param out_group: Output UIJson group.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    export_as: str | None = None
+    out_group: UIJsonGroup | None = None
+
+
+class BlockModel2OctreeOptions(BaseData):
+    """
+    Block model parameters for use with `block_models.driver`.
+
+    :param entity: BlockModel source object.
+    :param data: Optional data to refine the octree mesh.
+    :param output: Output options.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    name: ClassVar[str] = "block_model_to_octree"
+    default_ui_json: ClassVar[Path] = (
+        assets_path() / "uijson/block_model_to_octree.ui.json"
+    )
+    title: ClassVar[str] = "Block Model to Octree Conversion"
+    run_command: ClassVar[str] = "grid_apps.block_model_to_octree.driver"
+    conda_environment: str = "grid_apps"
+
+    entity: BlockModel
+    data: FloatData | ReferencedData | None = None
+
+    output: OutputOptions = OutputOptions()

grid_apps/block_models/__init__.py

@@ -0,0 +1,8 @@
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+#  Copyright (c) 2024-2025 Mira Geoscience Ltd.                                     '
+#                                                                                   '
+#  This file is part of grid-apps package.                                          '
+#                                                                                   '
+#  grid-apps is distributed under the terms and conditions of the MIT License       '
+#  (see LICENSE file at the root of this source code package).                      '
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''

grid_apps/block_models/driver.py

@@ -0,0 +1,207 @@
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+#  Copyright (c) 2024-2025 Mira Geoscience Ltd.                                     '
+#                                                                                   '
+#  This file is part of grid-apps package.                                          '
+#                                                                                   '
+#  grid-apps is distributed under the terms and conditions of the MIT License       '
+#  (see LICENSE file at the root of this source code package).                      '
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+
+from __future__ import annotations
+
+import logging
+import sys
+from pathlib import Path
+
+import numpy as np
+from discretize.utils import mesh_utils
+from geoapps_utils.driver.data import BaseData
+from geoh5py.objects import BlockModel
+from geoh5py.shared.utils import fetch_active_workspace
+from geoh5py.workspace import Workspace
+from scipy.spatial import cKDTree
+
+from grid_apps.block_models.options import BlockModelOptions
+from grid_apps.driver import BaseGridDriver
+
+
+logger = logging.getLogger(__name__)
+
+
+class Driver(BaseGridDriver):
+    """
+    Create BlockModel from parameters.
+
+    :param parameters: BlockModelOptions or InputFile containing the parameters.
+    """
+
+    _params_class = BlockModelOptions
+
+    def make_grid(self):
+        """
+        Make block model object from input data.
+        """
+        with fetch_active_workspace(self.params.geoh5, mode="r+"):
+            source_locations = self.params.source.objects.locations
+            if source_locations is None:
+                raise ValueError("Input object has no centroids or vertices.")
+
+            tree = cKDTree(source_locations)
+
+            logger.info("Creating block model . . .")
+
+            block_model = Driver.get_block_model(
+                workspace=self.params.geoh5,
+                locs=source_locations,
+                h=self.params.creation.cell_sizes,
+                depth_core=self.params.creation.depth_core,
+                pads=self.params.creation.padding,
+                expansion_factor=self.params.creation.expansion_factor,
+                name=self.params.output.export_as,
+            )
+
+            if self.params.output.out_group is not None:
+                block_model.parent = self.params.output.out_group
+
+            # Try to recenter on nearest
+            # Find nearest cells
+            if block_model.centroids is None:
+                raise ValueError("Block model has no centroids.")
+                # TODO: Remove once GEOPY-1602 is merged
+
+            neighbor_distances, neighbor_indices = tree.query(block_model.centroids)
+            nearest_neighbor = np.argmin(neighbor_distances)
+            source_to_nearest_neighbor = (
+                block_model.centroids[nearest_neighbor, :]
+                - source_locations[neighbor_indices[nearest_neighbor], :]
+            )
+            block_model.origin = (
+                np.r_[block_model.origin.tolist()] - source_to_nearest_neighbor
+            )
+
+        return block_model
+
+    @staticmethod
+    def truncate_locs_depths(locs: np.ndarray, depth_core: float) -> np.ndarray:
+        """
+        Sets locations below core to core bottom.
+
+        :param locs: Location points.
+        :param depth_core: Depth of core mesh below locs.
+
+        :return locs: locs with depths truncated.
+        """
+        zmax = locs[:, -1].max()  # top of locs
+        below_core_ind = (zmax - locs[:, -1]) > depth_core
+        core_bottom_elev = zmax - depth_core
+        locs[below_core_ind, -1] = (
+            core_bottom_elev  # sets locations below core to core bottom
+        )
+        return locs
+
+    @staticmethod
+    def minimum_depth_core(
+        locs: np.ndarray, depth_core: float, core_z_cell_size: int
+    ) -> float:
+        """
+        Get minimum depth core.
+
+        :param locs: Location points.
+        :param depth_core: Depth of core mesh below locs.
+        :param core_z_cell_size: Cell size in z direction.
+
+        :return depth_core: Minimum depth core.
+        """
+        zrange = locs[:, -1].max() - locs[:, -1].min()  # locs z range
+        if depth_core >= zrange:
+            return depth_core - zrange + core_z_cell_size
+
+        return depth_core
+
+    @staticmethod
+    def find_top_padding(obj: BlockModel, core_z_cell_size: int) -> float:
+        """
+        Loop through cell spacing and sum until core_z_cell_size is reached.
+
+        :param obj: Block model.
+        :param core_z_cell_size: Cell size in z direction.
+
+        :return pad_sum: Top padding.
+        """
+        pad_sum = 0.0
+
+        if obj.z_cell_delimiters is None:
+            raise ValueError("Block model has no z_cell_delimiters.")
+
+        for h in np.abs(np.diff(obj.z_cell_delimiters)):
+            if h != core_z_cell_size:
+                pad_sum += h
+            else:
+                break
+
+        return pad_sum
+
+    @staticmethod
+    def get_block_model(  # pylint: disable=too-many-arguments, too-many-positional-arguments
+        workspace: Workspace,
+        locs: np.ndarray,
+        h: list,
+        depth_core: float,
+        pads: list,
+        expansion_factor: float,
+        name: str = "BlockModel",
+    ) -> BlockModel:
+        """
+        Create a BlockModel object from parameters.
+
+        :param workspace: Workspace.
+        :param locs: Location points.
+        :param h: Cell size(s) for the core mesh.
+        :param depth_core: Depth of core mesh below locs.
+        :param pads: len(6) Padding distances [W, E, N, S, Down, Up]
+        :param expansion_factor: Expansion factor for padding cells.
+        :param name: Block model name.
+
+        :return object_out: Output block model.
+        """
+
+        locs = Driver.truncate_locs_depths(locs, depth_core)
+        depth_core = Driver.minimum_depth_core(locs, depth_core, h[2])
+        mesh = mesh_utils.mesh_builder_xyz(
+            locs,
+            h,
+            padding_distance=[
+                [pads[0], pads[1]],
+                [pads[2], pads[3]],
+                [pads[4], pads[5]],
+            ],
+            depth_core=depth_core,
+            expansion_factor=expansion_factor,
+        )
+
+        object_out = BlockModel.create(
+            workspace,
+            origin=[mesh.x0[0], mesh.x0[1], mesh.x0[2] + mesh.h[2].sum()],
+            u_cell_delimiters=mesh.nodes_x - mesh.x0[0],
+            v_cell_delimiters=mesh.nodes_y - mesh.x0[1],
+            z_cell_delimiters=-(mesh.x0[2] + mesh.h[2].sum() - mesh.nodes_z[::-1]),
+            name=name,
+        )
+
+        return object_out
+
+    @property
+    def params(self) -> BaseData:
+        """Application parameters."""
+        return self._params
+
+    @params.setter
+    def params(self, val: BaseData):
+        if not isinstance(val, BaseData):
+            raise TypeError("Parameters must be a BaseData subclass.")
+        self._params = val
+
+
+if __name__ == "__main__":
+    file = Path(sys.argv[1]).resolve()
+    Driver.start(file)

grid_apps/block_models/options.py

@@ -0,0 +1,104 @@
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+#  Copyright (c) 2024-2025 Mira Geoscience Ltd.                                     '
+#                                                                                   '
+#  This file is part of grid-apps package.                                          '
+#                                                                                   '
+#  grid-apps is distributed under the terms and conditions of the MIT License       '
+#  (see LICENSE file at the root of this source code package).                      '
+# '''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import ClassVar
+
+from geoapps_utils.driver.data import BaseData
+from geoh5py.groups import UIJsonGroup
+from geoh5py.objects import CellObject, Points
+from geoh5py.objects.grid_object import GridObject
+from pydantic import BaseModel, ConfigDict
+
+from grid_apps import assets_path
+
+
+class BlockModelSourceOptions(BaseModel):
+    """
+    Source parameters providing input data to the driver.
+
+    :param objects: A Grid2D, Octree, BlockModel, Points, Curve or
+        Surface source object.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    objects: Points | CellObject | GridObject
+
+
+class BlockModelCreationOptions(BaseModel):
+    """
+    Block model specification parameters.
+
+    :param cell_size_x: Cell size in x direction.
+    :param cell_size_y: Cell size in y direction.
+    :param cell_size_z: Cell size in z direction.
+    :param depth_core: Depth of core mesh below locs.
+    :param horizontal_padding: Horizontal padding.
+    :param bottom_padding: Bottom padding.
+    :param expansion_factor: Expansion factor for padding cells.
+    """
+
+    cell_size_x: float
+    cell_size_y: float
+    cell_size_z: float
+    depth_core: float
+    horizontal_padding: float
+    bottom_padding: float
+    expansion_factor: float
+
+    @property
+    def cell_sizes(self) -> list[float]:
+        """
+        Cell sizes in x, y and z directions.
+        """
+        return [self.cell_size_x, self.cell_size_y, self.cell_size_z]
+
+    @property
+    def padding(self) -> list[float]:
+        """
+        Padding distances in west, east, south, north, down and up directions.
+        """
+        return [self.horizontal_padding] * 4 + [self.bottom_padding, 0.0]
+
+
+class BlockModelOutputOptions(BaseModel):
+    """
+    Output parameters for block model creation.
+
+    :param export_as: Name of the output entity.
+    :param out_group: Name of the output group.
+    """
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    export_as: str = "block_model"
+    out_group: UIJsonGroup | None = None
+
+
+class BlockModelOptions(BaseData):
+    """
+    Block model parameters for use with `block_models.driver`.
+
+    :param source: Source data parameters.
+    :param creation: Block Model creation parameters.
+    :param output: Block Model output parameters.
+    """
+
+    name: ClassVar[str] = "block_model"
+    default_ui_json: ClassVar[Path] = assets_path() / "uijson/block_models.ui.json"
+    title: ClassVar[str] = "Block Model Creation"
+    run_command: ClassVar[str] = "grid_apps.block_models.driver"
+
+    conda_environment: str = "grid_apps"
+    source: BlockModelSourceOptions
+    creation: BlockModelCreationOptions
+    output: BlockModelOutputOptions = BlockModelOutputOptions()