subsurface-terra 2025.1.0rc15__py3-none-any.whl → 2025.1.0rc16__py3-none-any.whl

subsurface/core/structs/structured_elements/structured_grid.py

@@ -1,59 +1,59 @@
-import numpy as np
-from ..base_structures import StructuredData
-
-
-class StructuredGrid:
-    # TODO check structured_data has three coordinates
-    """Container for curvilinear mesh grids.
-
-        This is analogous to PyVista's StructuredGrid class or discretize's
-        CurviMesh class.
-
-    """
-
-    def __init__(self, structured_data: StructuredData):
-        self.ds = structured_data
-
-    @property
-    def cartesian_dimensions(self):
-        return len(self.cartesian_coords_names)
-
-    @property
-    def cartesian_coords_names(self):
-        coord_names = np.array(['X', 'Y', 'Z', 'x', 'y', 'z'])
-        return coord_names[np.isin(coord_names, self.ds.data.dims)]
-
-    @property
-    def coord(self):
-        return self.ds.data.coords
-
-    @property
-    def meshgrid_3d(self):
-        cart_coord = [self.coord[i] for i in self.cartesian_coords_names]
-        grid_3d = np.meshgrid(*cart_coord, indexing='ij')
-        return grid_3d
-
-    @property
-    def active_attributes(self) -> np.ndarray:
-        return self.ds.data[self.ds.active_data_array_name].values
-
-    def meshgrid_2d(self, attribute_name_coord_name: str = None) -> list:
-        """
-
-        Args:
-            attribute_name_coord_name(str): Name of the xarray.Dataset coord that
-             will be used for the z direction. This must be 2d
-
-        Returns:
-
-        """
-        grid_2d_: tuple = np.meshgrid(self.coord['x'], self.coord['y'])
-        grid_2d = list(grid_2d_)
-        if attribute_name_coord_name is not None:
-            z_coord = self.ds.data[attribute_name_coord_name].values.T
-            if z_coord.ndim != 2:
-                raise AttributeError('The attribute must be a 2D array')
-
-            grid_2d.append(z_coord)
-
-        return grid_2d
+import numpy as np
+from ..base_structures import StructuredData
+
+
+class StructuredGrid:
+    # TODO check structured_data has three coordinates
+    """Container for curvilinear mesh grids.
+
+        This is analogous to PyVista's StructuredGrid class or discretize's
+        CurviMesh class.
+
+    """
+
+    def __init__(self, structured_data: StructuredData):
+        self.ds = structured_data
+
+    @property
+    def cartesian_dimensions(self):
+        return len(self.cartesian_coords_names)
+
+    @property
+    def cartesian_coords_names(self):
+        coord_names = np.array(['X', 'Y', 'Z', 'x', 'y', 'z'])
+        return coord_names[np.isin(coord_names, self.ds.data.dims)]
+
+    @property
+    def coord(self):
+        return self.ds.data.coords
+
+    @property
+    def meshgrid_3d(self):
+        cart_coord = [self.coord[i] for i in self.cartesian_coords_names]
+        grid_3d = np.meshgrid(*cart_coord, indexing='ij')
+        return grid_3d
+
+    @property
+    def active_attributes(self) -> np.ndarray:
+        return self.ds.data[self.ds.active_data_array_name].values
+
+    def meshgrid_2d(self, attribute_name_coord_name: str = None) -> list:
+        """
+
+        Args:
+            attribute_name_coord_name(str): Name of the xarray.Dataset coord that
+             will be used for the z direction. This must be 2d
+
+        Returns:
+
+        """
+        grid_2d_: tuple = np.meshgrid(self.coord['x'], self.coord['y'])
+        grid_2d = list(grid_2d_)
+        if attribute_name_coord_name is not None:
+            z_coord = self.ds.data[attribute_name_coord_name].values.T
+            if z_coord.ndim != 2:
+                raise AttributeError('The attribute must be a 2D array')
+
+            grid_2d.append(z_coord)
+
+        return grid_2d

subsurface/core/structs/structured_elements/structured_mesh.py

@@ -1,9 +1,9 @@
-from subsurface import StructuredData
-
-
-class StructuredSurface:
-    def __init__(self, structured_data: StructuredData):
-        # TODO check structured_data has two coordinates
-        self.ds = structured_data
-
-    # Add pyvista methods of gridded data
+from subsurface import StructuredData
+
+
+class StructuredSurface:
+    def __init__(self, structured_data: StructuredData):
+        # TODO check structured_data has two coordinates
+        self.ds = structured_data
+
+    # Add pyvista methods of gridded data

subsurface/core/structs/unstructured_elements/__init__.py

@@ -1,4 +1,4 @@
-from .triangular_surface import TriSurf
-from .line_set import LineSet
-from .point_set import PointSet
+from .triangular_surface import TriSurf
+from .line_set import LineSet
+from .point_set import PointSet
 from .tetrahedron_mesh import TetraMesh

subsurface/core/structs/unstructured_elements/line_set.py

@@ -1,72 +1,72 @@
-import numpy as np
-import pandas as pd
-
-from ..base_structures import UnstructuredData
-
-
-class LineSet:
-    """PointSet with line cells.
-
-    This dataset defines cell connectivity between points to create
-    line segments.
-
-    Args:
-        data (UnstructuredData): Base object for unstructured data.
-
-         data.cells represent the indices of the end points for each
-         line segment in the mesh. Each column corresponds to a line
-         segment. If not specified, the vertices are connected in order,
-         equivalent to ``segments=[[0, 1], [1, 2], [2, 3], ...]``
-
-        radius (float): Thickness of the line set
-    """
-
-    def __init__(self, data: UnstructuredData, radius: float = 1):
-
-        self.data: UnstructuredData = data
-        self.radius = radius
-
-        if data.cells is None or data.cells.shape[1] < 2:
-            self.generate_default_cells()
-
-        elif data.cells.shape[1] != 2:
-            raise AttributeError('data.cells must be of the format'
-                                 'NDArray[(Any, 2), IntX]')
-
-        # TODO: these must all be integer dtypes!
-
-    def get_first_index_per_well(self, attr_hole_id: str):
-        """ Method to get the first index of each well in the LineSet
-
-        Returns:
-            np.ndarray[(Any,), IntX]
-
-        """
-        import xarray as xr
-        dataset: xr.Dataset = self.data.data
-        dataframe: pd.DataFrame = self.data.attributes
-        array = dataframe[attr_hole_id].values
-        
-        first_index = np.where(array[:-1] != array[1:])[0]
-        return first_index
-        
-    
-    def generate_default_cells(self):
-        """ Method to generate cells based on the order of the vertex. This
-        only works if the LineSet only represents one single line
-
-        Returns:
-            np.ndarray[(Any, 2), IntX]
-
-        """
-        a = np.arange(0, self.data.n_points - 1, dtype=np.int_)
-        b = np.arange(1, self.data.n_points, dtype=np.int_)
-        return np.vstack([a, b]).T
-
-    @property
-    def segments(self):
-        return self.data.cells
-
-    @property
-    def n_segments(self):
-        return self.segments.shape[0]
+import numpy as np
+import pandas as pd
+
+from ..base_structures import UnstructuredData
+
+
+class LineSet:
+    """PointSet with line cells.
+
+    This dataset defines cell connectivity between points to create
+    line segments.
+
+    Args:
+        data (UnstructuredData): Base object for unstructured data.
+
+         data.cells represent the indices of the end points for each
+         line segment in the mesh. Each column corresponds to a line
+         segment. If not specified, the vertices are connected in order,
+         equivalent to ``segments=[[0, 1], [1, 2], [2, 3], ...]``
+
+        radius (float): Thickness of the line set
+    """
+
+    def __init__(self, data: UnstructuredData, radius: float = 1):
+
+        self.data: UnstructuredData = data
+        self.radius = radius
+
+        if data.cells is None or data.cells.shape[1] < 2:
+            self.generate_default_cells()
+
+        elif data.cells.shape[1] != 2:
+            raise AttributeError('data.cells must be of the format'
+                                 'NDArray[(Any, 2), IntX]')
+
+        # TODO: these must all be integer dtypes!
+
+    def get_first_index_per_well(self, attr_hole_id: str):
+        """ Method to get the first index of each well in the LineSet
+
+        Returns:
+            np.ndarray[(Any,), IntX]
+
+        """
+        import xarray as xr
+        dataset: xr.Dataset = self.data.data
+        dataframe: pd.DataFrame = self.data.attributes
+        array = dataframe[attr_hole_id].values
+        
+        first_index = np.where(array[:-1] != array[1:])[0]
+        return first_index
+        
+    
+    def generate_default_cells(self):
+        """ Method to generate cells based on the order of the vertex. This
+        only works if the LineSet only represents one single line
+
+        Returns:
+            np.ndarray[(Any, 2), IntX]
+
+        """
+        a = np.arange(0, self.data.n_points - 1, dtype=np.int_)
+        b = np.arange(1, self.data.n_points, dtype=np.int_)
+        return np.vstack([a, b]).T
+
+    @property
+    def segments(self):
+        return self.data.cells
+
+    @property
+    def n_segments(self):
+        return self.segments.shape[0]

subsurface/core/structs/unstructured_elements/point_set.py

@@ -1,43 +1,43 @@
-from dataclasses import dataclass
-
-from ..base_structures import UnstructuredData
-
-
-@dataclass
-class PointSet:
-    """Class for pointset based data structures.
-
-    This class uses UnstructuredData.vertex as cloud of points and the
-    associated attributes. UnstructuredData.cells are not used.
-
-    Args:
-        data (UnstructuredData): Base object for unstructured data.
-
-    """
-    data: UnstructuredData
-    
-    def __init__(self, data: UnstructuredData):
-        if data.cells.shape[1] > 1:
-            raise AttributeError('data.cells must be of the format'
-                                 'NDArray[(Any, 0), IntX] or NDArray[(Any, 1), IntX]')
-
-        self.data = data
-
-    @property
-    def points(self) -> "np.ndarray":
-        """Fetch the points/vertices dataframe."""
-        return self.data.vertex
-
-    @property
-    def n_points(self):
-        return self.data.vertex.shape[0]
-
-    @property
-    def point_data(self):
-        """Fetch the scalar data associated with the vertices."""
-        return self.data.attributes
-
-    @property
-    def point_data_dict(self):
-        """Fetch the point data as a dictionary of numpy arrays."""
-        return self.data.attributes_to_dict
+from dataclasses import dataclass
+
+from ..base_structures import UnstructuredData
+
+
+@dataclass
+class PointSet:
+    """Class for pointset based data structures.
+
+    This class uses UnstructuredData.vertex as cloud of points and the
+    associated attributes. UnstructuredData.cells are not used.
+
+    Args:
+        data (UnstructuredData): Base object for unstructured data.
+
+    """
+    data: UnstructuredData
+    
+    def __init__(self, data: UnstructuredData):
+        if data.cells.shape[1] > 1:
+            raise AttributeError('data.cells must be of the format'
+                                 'NDArray[(Any, 0), IntX] or NDArray[(Any, 1), IntX]')
+
+        self.data = data
+
+    @property
+    def points(self) -> "np.ndarray":
+        """Fetch the points/vertices dataframe."""
+        return self.data.vertex
+
+    @property
+    def n_points(self):
+        return self.data.vertex.shape[0]
+
+    @property
+    def point_data(self):
+        """Fetch the scalar data associated with the vertices."""
+        return self.data.attributes
+
+    @property
+    def point_data_dict(self):
+        """Fetch the point data as a dictionary of numpy arrays."""
+        return self.data.attributes_to_dict

subsurface/core/structs/unstructured_elements/tetrahedron_mesh.py

@@ -1,35 +1,35 @@
-from ..base_structures import UnstructuredData
-
-
-class TetraMesh:
-    """PointSet with tetrahedron cells.
-
-    This dataset defines cell connectivity between points to create
-    tetrahedrons. This is volumetric.
-
-    Args:
-
-        data (UnstructuredData): Base object for unstructured data.
-
-         data.cells represent the indices of the points for each
-         tetrahedron in the mesh. Each column corresponds to a tetrahedron.
-         Every tetrahedron is defined by the four points; where the first
-         three (0,1,2) are the base of the tetrahedron which, using the
-         right hand rule, forms a triangle whose normal points in the
-         direction of the fourth point.
-
-    """
-
-    def __init__(self, data: UnstructuredData):
-        if data.cells.shape[1] != 4:
-            raise AttributeError('data.cells must be of the format'
-                                 'NDArray[(Any, 4), IntX]')
-        self.data = data
-
-    @property
-    def tetrahedrals(self):
-        return self.data.cells
-
-    @property
-    def n_tetrahedrals(self):
-        return self.tetrahedrals.shape[0]
+from ..base_structures import UnstructuredData
+
+
+class TetraMesh:
+    """PointSet with tetrahedron cells.
+
+    This dataset defines cell connectivity between points to create
+    tetrahedrons. This is volumetric.
+
+    Args:
+
+        data (UnstructuredData): Base object for unstructured data.
+
+         data.cells represent the indices of the points for each
+         tetrahedron in the mesh. Each column corresponds to a tetrahedron.
+         Every tetrahedron is defined by the four points; where the first
+         three (0,1,2) are the base of the tetrahedron which, using the
+         right hand rule, forms a triangle whose normal points in the
+         direction of the fourth point.
+
+    """
+
+    def __init__(self, data: UnstructuredData):
+        if data.cells.shape[1] != 4:
+            raise AttributeError('data.cells must be of the format'
+                                 'NDArray[(Any, 4), IntX]')
+        self.data = data
+
+    @property
+    def tetrahedrals(self):
+        return self.data.cells
+
+    @property
+    def n_tetrahedrals(self):
+        return self.tetrahedrals.shape[0]

subsurface/core/structs/unstructured_elements/triangular_surface.py

@@ -1,62 +1,62 @@
-from ..base_structures import UnstructuredData, StructuredData
-
-
-class TriSurf:
-    """PointSet with triangle cells.
-
-    This dataset defines cell/element connectivity between points to create
-    triangulated surface.
-
-    Uses UnstructuredData.cells for the face connectivity.
-
-    Args:
-        mesh (UnstructuredData): Base object for unstructured data.
-         data.cells  represent the point indices for each triangle
-         in the mesh. Each column corresponds to a triangle edge.
-        texture (StructuredData): 2D StructuredData with data to be mapped
-         on the mesh
-
-    Keyword Args:
-        texture_origin : tuple(float)
-            Length 3 iterable of floats defining the XYZ coordinates of the
-            BOTTOM LEFT CORNER of the plane
-
-        texture_point_u : tuple(float)
-            Length 3 iterable of floats defining the XYZ coordinates of the
-            BOTTOM RIGHT CORNER of the plane
-
-        texture_point_v : tuple(float)
-            Length 3 iterable of floats defining the XYZ coordinates of the
-            TOP LEFT CORNER of the plane
-    """
-
-    def __init__(self,
-                 mesh: UnstructuredData,
-                 texture: StructuredData = None,
-                 **kwargs
-                 ):
-        if mesh.cells.shape[1] != 3:
-            raise AttributeError('data.cells must be of the format'
-                                 'NDArray[(Any, 3), IntX]')
-
-        self.mesh: UnstructuredData = mesh
-        self.texture: StructuredData = texture
-        self.texture_origin = kwargs.get('texture_origin', None)
-        self.texture_point_u = kwargs.get('texture_point_u', None)
-        self.texture_point_v = kwargs.get('texture_point_v', None)
-
-    @property
-    def has_texture_data_without_uv(self):
-        return self.texture is not None and self.texture_origin is not None and self.texture_point_u is not None and self.texture_point_v is not None
-    
-    @property
-    def has_texture_data_with_uv(self):
-        return 'u' in self.mesh.points_attributes and 'v' in self.mesh.points_attributes
-    
-    @property
-    def triangles(self):
-        return self.mesh.cells
-
-    @property
-    def n_triangles(self):
-        return self.mesh.cells.shape[0]
+from ..base_structures import UnstructuredData, StructuredData
+
+
+class TriSurf:
+    """PointSet with triangle cells.
+
+    This dataset defines cell/element connectivity between points to create
+    triangulated surface.
+
+    Uses UnstructuredData.cells for the face connectivity.
+
+    Args:
+        mesh (UnstructuredData): Base object for unstructured data.
+         data.cells  represent the point indices for each triangle
+         in the mesh. Each column corresponds to a triangle edge.
+        texture (StructuredData): 2D StructuredData with data to be mapped
+         on the mesh
+
+    Keyword Args:
+        texture_origin : tuple(float)
+            Length 3 iterable of floats defining the XYZ coordinates of the
+            BOTTOM LEFT CORNER of the plane
+
+        texture_point_u : tuple(float)
+            Length 3 iterable of floats defining the XYZ coordinates of the
+            BOTTOM RIGHT CORNER of the plane
+
+        texture_point_v : tuple(float)
+            Length 3 iterable of floats defining the XYZ coordinates of the
+            TOP LEFT CORNER of the plane
+    """
+
+    def __init__(self,
+                 mesh: UnstructuredData,
+                 texture: StructuredData = None,
+                 **kwargs
+                 ):
+        if mesh.cells.shape[1] != 3:
+            raise AttributeError('data.cells must be of the format'
+                                 'NDArray[(Any, 3), IntX]')
+
+        self.mesh: UnstructuredData = mesh
+        self.texture: StructuredData = texture
+        self.texture_origin = kwargs.get('texture_origin', None)
+        self.texture_point_u = kwargs.get('texture_point_u', None)
+        self.texture_point_v = kwargs.get('texture_point_v', None)
+
+    @property
+    def has_texture_data_without_uv(self):
+        return self.texture is not None and self.texture_origin is not None and self.texture_point_u is not None and self.texture_point_v is not None
+    
+    @property
+    def has_texture_data_with_uv(self):
+        return 'u' in self.mesh.points_attributes and 'v' in self.mesh.points_attributes
+    
+    @property
+    def triangles(self):
+        return self.mesh.cells
+
+    @property
+    def n_triangles(self):
+        return self.mesh.cells.shape[0]

subsurface/core/utils/utils_core.py

@@ -1,38 +1,38 @@
-from typing import Union
-
-from pathlib import Path
-
-from ..structs import StructuredData, UnstructuredData
-
-
-def get_extension(path):
-    try:
-        p = Path(path)
-        return p.suffix
-    except TypeError:
-        return False
-
-
-def replace_outliers(base_data: Union[StructuredData, UnstructuredData], dim=0, perc=0.99, replace_for=None):
-    """@Edoardo Guerreiro https://stackoverflow.com/questions/60816533/
-     is-there-a-built-in-function-in-xarray-to-remove-outliers-from-a-dataset"""
-
-    data = base_data.data
-    # calculate percentile
-    threshold = data[dim].quantile(perc)
-
-    # find outliers and replace them with max among remaining values
-    mask = data[dim].where(abs(data[dim]) <= threshold)
-    if replace_for == 'max':
-        max_value = mask.max().values
-        # .where replace outliers with nan
-        mask = mask.fillna(max_value)
-    elif replace_for == 'min':
-        min_value = mask.min().values
-        # .where replace outliers with nan
-        mask = mask.fillna(min_value)
-
-    print(mask)
-    data[dim] = mask
-
-    return data
+from typing import Union
+
+from pathlib import Path
+
+from ..structs import StructuredData, UnstructuredData
+
+
+def get_extension(path):
+    try:
+        p = Path(path)
+        return p.suffix
+    except TypeError:
+        return False
+
+
+def replace_outliers(base_data: Union[StructuredData, UnstructuredData], dim=0, perc=0.99, replace_for=None):
+    """@Edoardo Guerreiro https://stackoverflow.com/questions/60816533/
+     is-there-a-built-in-function-in-xarray-to-remove-outliers-from-a-dataset"""
+
+    data = base_data.data
+    # calculate percentile
+    threshold = data[dim].quantile(perc)
+
+    # find outliers and replace them with max among remaining values
+    mask = data[dim].where(abs(data[dim]) <= threshold)
+    if replace_for == 'max':
+        max_value = mask.max().values
+        # .where replace outliers with nan
+        mask = mask.fillna(max_value)
+    elif replace_for == 'min':
+        min_value = mask.min().values
+        # .where replace outliers with nan
+        mask = mask.fillna(min_value)
+
+    print(mask)
+    data[dim] = mask
+
+    return data