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

subsurface/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2025.1.0rc14'
-__version_tuple__ = version_tuple = (2025, 1, 0, 'rc14')
+__version__ = version = '2025.1.0rc15'
+__version_tuple__ = version_tuple = (2025, 1, 0, 'rc15')

subsurface/core/geological_formats/boreholes/_map_attrs_to_survey.py

@@ -0,0 +1,234 @@
+import numpy as np
+import pandas as pd
+import xarray as xr
+from scipy.interpolate import interp1d
+from typing import Tuple, Optional, Union, List, Any
+
+from ...structs.base_structures import UnstructuredData
+from ...structs.base_structures._unstructured_data_constructor import raw_attributes_to_dict_data_arrays
+from ...structs.unstructured_elements import LineSet
+
+
+def combine_survey_and_attrs(attrs: pd.DataFrame, survey_trajectory: LineSet,well_id_mapper: dict[str, int]) -> UnstructuredData:
+    # Import moved to top for clarity and possibly avoiding repeated imports if called multiple times
+
+    # Ensure all columns in lith exist in new_attrs, if not, add them as NaN
+    new_attrs = _map_attrs_to_measured_depths(attrs, survey_trajectory, well_id_mapper)
+
+    # Construct the final xarray dict without intermediate variable
+    points_attributes_xarray_dict: dict[str, xr.DataArray] = raw_attributes_to_dict_data_arrays(
+        default_attributes_name="vertex_attrs",
+        n_items=survey_trajectory.data.data["vertex_attrs"].shape[0],  # TODO: Can I look this on new_attrs to remove line 11?
+        dims=["points", "vertex_attr"],
+        raw_attributes=new_attrs
+    )
+
+    # Inline construction of UnstructuredData
+    return UnstructuredData.from_data_arrays_dict(
+        xarray_dict={
+                "vertex"      : survey_trajectory.data.data["vertex"],
+                "cells"       : survey_trajectory.data.data["cells"],
+                "vertex_attrs": points_attributes_xarray_dict["vertex_attrs"],
+                "cell_attrs"  : survey_trajectory.data.data["cell_attrs"]
+        },
+        xarray_attributes=survey_trajectory.data.data.attrs,
+        default_cells_attributes_name=survey_trajectory.data.cells_attr_name,
+        default_points_attributes_name=survey_trajectory.data.vertex_attr_name
+    )
+
+def _prepare_categorical_data(attrs: pd.DataFrame) -> pd.DataFrame:
+    """
+    Prepare categorical data for interpolation by converting categorical columns to numeric IDs.
+
+    Args:
+        attrs: DataFrame containing attribute data
+
+    Returns:
+        Modified DataFrame with categorical data prepared for interpolation
+    """
+    # Create a copy to avoid modifying the original
+    attrs_copy = attrs.copy()
+
+    # If component lith exists but lith_ids doesn't, create lith_ids
+    if 'component lith' in attrs_copy.columns and 'lith_ids' not in attrs_copy.columns:
+        attrs_copy['lith_ids'], _ = pd.factorize(attrs_copy['component lith'], use_na_sentinel=True)
+
+    return attrs_copy
+
+
+def _prepare_new_attributes(attrs: pd.DataFrame, survey_trajectory: LineSet) -> pd.DataFrame:
+    """
+    Prepare the new attributes DataFrame by adding missing columns from attrs.
+
+    Args:
+        attrs: DataFrame containing attribute data
+        survey_trajectory: LineSet containing trajectory data
+
+    Returns:
+        New attributes DataFrame with all necessary columns
+    """
+    # Start with a copy of the existing attributes DataFrame
+    new_attrs = survey_trajectory.data.points_attributes.copy()
+
+    # Add missing columns from attrs, preserving their dtypes
+    for col in attrs.columns.difference(new_attrs.columns):
+        new_attrs[col] = np.nan if pd.api.types.is_numeric_dtype(attrs[col]) else None
+
+    return new_attrs
+
+
+def _get_interpolation_locations(attrs_well: pd.DataFrame, well_name: str) -> np.ndarray:
+    """
+    Determine the locations to use for interpolation based on top and base values.
+
+    Args:
+        attrs_well: DataFrame containing well attribute data
+        well_name: Name of the current well
+
+    Returns:
+        Array of location values to use for interpolation
+    """
+    if "base" not in attrs_well.columns:
+        raise ValueError(f"Base column must be present in the file for well '{well_name}'.")
+    elif "top" not in attrs_well.columns:
+        return attrs_well['base'].values
+    else:
+        return ((attrs_well['top'] + attrs_well['base']) / 2).values
+
+
+def _nearest_neighbor_categorical_interpolation(
+    x_locations: np.ndarray,
+    y_values: np.ndarray,
+    target_depths: np.ndarray
+) -> np.ndarray:
+    """
+    Custom nearest neighbor interpolation for categorical data.
+
+    This function finds the nearest source point for each target point
+    and assigns the corresponding categorical value.
+
+    Args:
+        x_locations: Array of source locations
+        y_values: Array of categorical values at source locations
+        target_depths: Array of target depths for interpolation
+
+    Returns:
+        Array of interpolated categorical values
+    """
+    # Initialize output array with NaN or None values
+    result = np.full(target_depths.shape, np.nan, dtype=object)
+
+    # For each target depth, find the nearest source location
+    for i, depth in enumerate(target_depths):
+        # Calculate distances to all source locations
+        distances = np.abs(x_locations - depth)
+
+        # Find the index of the minimum distance
+        if len(distances) > 0:
+            nearest_idx = np.argmin(distances)
+            result[i] = y_values[nearest_idx]
+
+    return result
+
+
+def _interpolate_attribute(
+    attr_values: pd.Series, 
+    x_locations: np.ndarray, 
+    target_depths: np.ndarray, 
+    column_name: str,
+    is_categorical: bool
+) -> np.ndarray:
+    """
+    Interpolate attribute values to target depths.
+
+    Args:
+        attr_values: Series containing attribute values
+        x_locations: Array of source locations for interpolation
+        target_depths: Array of target depths for interpolation
+        column_name: Name of the column being interpolated
+        is_categorical: Whether the attribute is categorical
+
+    Returns:
+        Array of interpolated values
+    """
+    # For categorical data or specific columns, use custom nearest neighbor interpolation
+    if is_categorical or column_name in ['lith_ids', 'component lith']:
+        return _nearest_neighbor_categorical_interpolation(
+            x_locations=x_locations,
+            y_values=attr_values.values,
+            target_depths=target_depths
+        )
+    else:
+        # For numerical data, use scipy's interp1d with linear interpolation
+        interp_func = interp1d(
+            x=x_locations,
+            y=attr_values.values,
+            bounds_error=False,
+            fill_value=np.nan,
+            kind='linear'
+        )
+        return interp_func(target_depths)
+
+
+def _map_attrs_to_measured_depths(attrs: pd.DataFrame, survey_trajectory: LineSet, well_id_mapper: dict[str, int]) -> pd.DataFrame:
+    """
+    Map attributes to measured depths for each well.
+
+    Args:
+        attrs: DataFrame containing attribute data
+        survey_trajectory: LineSet containing trajectory data
+        well_id_mapper: Dictionary mapping well names to IDs
+
+    Returns:
+        DataFrame with attributes mapped to measured depths
+    """
+    # Extract trajectory data
+    trajectory: xr.DataArray = survey_trajectory.data.data["vertex_attrs"]
+    trajectory_well_id: xr.DataArray = trajectory.sel({'vertex_attr': 'well_id'})
+    measured_depths: np.ndarray = trajectory.sel({'vertex_attr': 'measured_depths'}).values.astype(np.float64)
+
+    # Prepare data
+    attrs: pd.DataFrame = _prepare_categorical_data(attrs)
+    new_attrs: pd.DataFrame = _prepare_new_attributes(attrs, survey_trajectory)
+
+    # Process each well
+    for well_name in well_id_mapper:
+        # Skip wells not in the attributes DataFrame
+        if well_name not in attrs.index:
+            print(f"Well '{well_name}' does not exist in the attributes DataFrame.")
+            continue
+
+        # Get well data
+        attrs_well = attrs.loc[[well_name]]
+        well_id = well_id_mapper.get(well_name)
+        well_mask = (trajectory_well_id == well_id).values
+        well_depths = measured_depths[well_mask]
+
+        # Get interpolation locations
+        interp_locations = _get_interpolation_locations(attrs_well, well_name)
+
+        # Interpolate each attribute
+        for col in attrs_well.columns:
+            # Skip location and ID columns
+            if col in ['top', 'base', 'well_id']:
+                continue
+
+            attr_values = attrs_well[col]
+            is_categorical = attr_values.dtype == 'O' or isinstance(attr_values.dtype, pd.CategoricalDtype)
+
+            # Skip columns that can't be interpolated and aren't categorical
+            if is_categorical and col not in ['lith_ids', 'component lith']:
+                continue
+
+            # Interpolate and assign values
+            interpolated_values = _interpolate_attribute(
+                attr_values, 
+                interp_locations, 
+                well_depths, 
+                col,
+                is_categorical
+            )
+
+            new_attrs.loc[well_mask, col] = interpolated_values
+
+    return new_attrs

subsurface/core/geological_formats/boreholes/_survey_to_unstruct.py

@@ -0,0 +1,163 @@
+from typing import Hashable, Optional
+
+import numpy as np
+import pandas as pd
+
+from subsurface import optional_requirements
+from ...structs.base_structures import UnstructuredData
+
+
+def data_frame_to_unstructured_data(survey_df: 'pd.DataFrame', number_nodes: int, attr_df: Optional['pd.DataFrame'] = None,
+                                     duplicate_attr_depths: bool = False) -> UnstructuredData:
+    wp = optional_requirements.require_wellpathpy()
+
+    cum_vertex: np.ndarray = np.empty((0, 3), dtype=np.float32)
+    cells: np.ndarray = np.empty((0, 2), dtype=np.int_)
+    cell_attr: pd.DataFrame = pd.DataFrame(columns=['well_id'], dtype=np.float32)
+    vertex_attr: pd.DataFrame = pd.DataFrame()
+
+    for e, (borehole_id, data) in enumerate(survey_df.groupby(level=0)):
+        dev = wp.deviation(
+            md=data['md'].values,
+            inc=data['inc'].values,
+            azi=data['azi'].values
+        )
+
+        md_min = dev.md.min()
+        md_max = dev.md.max()
+
+        attr_depths = _grab_depths_from_attr(
+            attr_df=attr_df,
+            borehole_id=borehole_id,
+            duplicate_attr_depths=duplicate_attr_depths,
+            md_max=md_max,
+            md_min=md_min
+        )
+
+        # Now combine attr_depths with depths
+        md_min = dev.md.min()
+        md_max = dev.md.max()
+        depths = np.linspace(md_min, md_max, number_nodes)
+        depths = np.union1d(depths, attr_depths)
+        depths.sort()
+
+        # Resample positions at depths
+        pos = dev.minimum_curvature().resample(depths=depths)
+        vertex_count = cum_vertex.shape[0]
+
+        this_well_vertex = np.vstack([pos.easting, pos.northing, pos.depth]).T
+        cum_vertex = np.vstack([cum_vertex, this_well_vertex])
+        measured_depths = _calculate_distances(array_of_vertices=this_well_vertex)
+
+        n_vertex_shift_0 = np.arange(0, len(pos.depth) - 1, dtype=np.int_)
+        n_vertex_shift_1 = np.arange(1, len(pos.depth), dtype=np.int_)
+        cell_per_well = np.vstack([n_vertex_shift_0, n_vertex_shift_1]).T + vertex_count
+        cells = np.vstack([cells, cell_per_well])
+
+        attribute_values = np.isin(depths, attr_depths)
+
+        vertex_attr_per_well = pd.DataFrame({
+                'well_id'        : [e] * len(pos.depth),
+                'measured_depths': measured_depths,
+                'is_attr_point'  : attribute_values,
+        })
+
+        vertex_attr = pd.concat([vertex_attr, vertex_attr_per_well], ignore_index=True)
+
+        # Add the id (e), to cell_attr
+        cell_attr = pd.concat([cell_attr, pd.DataFrame({'well_id': [e] * len(cell_per_well)})], ignore_index=True)
+
+    unstruct = UnstructuredData.from_array(
+        vertex=cum_vertex,
+        cells=cells.astype(int),
+        vertex_attr=vertex_attr.reset_index(drop=True),
+        cells_attr=cell_attr.reset_index(drop=True)
+    )
+
+    unstruct.data.attrs["well_id_mapper"] = {well_id: e for e, well_id in enumerate(survey_df.index.unique(level=0))}
+
+    return unstruct
+
+
+def _grab_depths_from_attr(
+        attr_df: pd.DataFrame,
+        borehole_id: Hashable,
+        duplicate_attr_depths: bool,
+        md_max: float,
+        md_min: float
+) -> np.ndarray:
+    # Initialize attr_depths and attr_labels as empty arrays
+    attr_depths = np.array([], dtype=float)
+    attr_labels = np.array([], dtype='<U4')  # Initialize labels for 'top' and 'base'
+
+    if attr_df is None or ("top" not in attr_df.columns and "base" not in attr_df.columns):
+        return attr_depths
+
+    try:
+        vals = attr_df.loc[borehole_id]
+
+        tops = np.array([], dtype=float)
+        bases = np.array([], dtype=float)
+
+        if 'top' in vals:
+            if isinstance(vals, pd.DataFrame):
+                tops = vals['top'].values.flatten()
+            else:
+                tops = np.array([vals['top']])
+            # Convert to float and remove NaNs
+            tops = tops.astype(float)
+            tops = tops[~np.isnan(tops)]
+            # Clip to within md range
+            tops = tops[(tops >= md_min) & (tops <= md_max)]
+
+        if 'base' in vals:
+            if isinstance(vals, pd.DataFrame):
+                bases = vals['base'].values.flatten()
+            else:
+                bases = np.array([vals['base']])
+            # Convert to float and remove NaNs
+            bases = bases.astype(float)
+            bases = bases[~np.isnan(bases)]
+            # Clip to within md range
+            bases = bases[(bases >= md_min) & (bases <= md_max)]
+
+        # Combine tops and bases into attr_depths with labels
+        attr_depths = np.concatenate((tops, bases))
+        attr_labels = np.array(['top'] * len(tops) + ['base'] * len(bases))
+
+        # Drop duplicates while preserving order
+        _, unique_indices = np.unique(attr_depths, return_index=True)
+        attr_depths = attr_depths[unique_indices]
+        attr_labels = attr_labels[unique_indices]
+
+    except KeyError:
+        # No attributes for this borehole_id or missing columns
+        attr_depths = np.array([], dtype=float)
+        attr_labels = np.array([], dtype='<U4')
+
+    # If duplicate_attr_depths is True, duplicate attr_depths with a tiny offset
+    if duplicate_attr_depths and len(attr_depths) > 0:
+        tiny_offset = (md_max - md_min) * 1e-6  # A tiny fraction of the depth range
+        # Create offsets: +tiny_offset for 'top', -tiny_offset for 'base'
+        offsets = np.where(attr_labels == 'top', tiny_offset, -tiny_offset)
+        duplicated_attr_depths = attr_depths + offsets
+        # Ensure the duplicated depths are within the md range
+        valid_indices = (duplicated_attr_depths >= md_min) & (duplicated_attr_depths <= md_max)
+        duplicated_attr_depths = duplicated_attr_depths[valid_indices]
+        # Original attribute depths
+        original_attr_depths = attr_depths
+        # Combine originals and duplicates
+        attr_depths = np.hstack([original_attr_depths, duplicated_attr_depths])
+
+    return attr_depths
+
+
+def _calculate_distances(array_of_vertices: np.ndarray) -> np.ndarray:
+    # Calculate the differences between consecutive points
+    differences = np.diff(array_of_vertices, axis=0)
+
+    # Calculate the Euclidean distance for each pair of consecutive points
+    distances = np.linalg.norm(differences, axis=1)
+    # Insert a 0 at the beginning to represent the starting point at the surface
+    measured_depths = np.insert(np.cumsum(distances), 0, 0)
+    return measured_depths

subsurface/core/geological_formats/boreholes/boreholes.py

@@ -1,7 +1,7 @@
 import numpy as np
 import pandas as pd
 from dataclasses import dataclass
-from typing import Hashable
+from typing import Hashable, Literal
 
 from ._combine_trajectories import create_combined_trajectory, MergeOptions
 from .collars import Collars
@@ -69,10 +69,10 @@ class BoreholeSet:
         # I need to implement the survey to and then name the files accordingly
         bytearray_le_collars: bytes = self.collars.data.to_binary()
         bytearray_le_trajectory: bytes = self.combined_trajectory.data.to_binary()
-        
+
         new_file = open(f"{path}_collars.le", "wb")
         new_file.write(bytearray_le_collars)
-        
+
         new_file = open(f"{path}_trajectory.le", "wb")
         new_file.write(bytearray_le_trajectory)
         return True
@@ -88,13 +88,37 @@ class BoreholeSet:
 
         return component_lith_arrays
 
-    def get_bottom_coords_for_each_lith(self) -> dict[Hashable, np.ndarray]:
+    def get_bottom_coords_for_each_lith(self, group_by: Literal['component lith', 'lith_ids'] = 'lith_ids') -> dict[Hashable, np.ndarray]:
+        """
+        Retrieves the bottom coordinates for each lithological component or lith ID from
+        the merged vertex data arrays.
+
+        This function groups the merged data by either 'component lith' or 'lith_ids',
+        then extracts the coordinates of the bottommost vertices for each well. It
+        returns a dictionary where keys are either lithological component identifiers
+        or lith IDs, and values are arrays of 3D coordinates representing the bottom
+        vertices.
+
+        Args:
+            group_by (Literal['component lith', 'lith_ids']): Specifies the grouping
+                column to use for lithological components. Acceptable values are either
+                'component lith' or 'lith_ids'. Defaults to 'lith_ids'.
+
+        Returns:
+            dict[Hashable, np.ndarray]: A dictionary mapping the lithological component
+            or lith ID to an array of 3D coordinates ([X, Y, Z]) corresponding to the
+            bottom vertices for each well.
+
+        Raises:
+            ValueError: If no groups are found from the specified `group_by` column.
+        """
         merged_df = self._merge_vertex_data_arrays_to_dataframe()
         component_lith_arrays = {}
-        groupby = merged_df.groupby('lith_ids')
-        if groupby.ngroups == 0:
+        group = merged_df.groupby(group_by)
+
+        if group.ngroups == 0:
             raise ValueError("No components found")
-        for lith, group in groupby:
+        for lith, group in group:
             lith = int(lith)
             first_vertices = group.groupby('well_id').last().reset_index()
             array = first_vertices[['X', 'Y', 'Z']].values

subsurface/core/geological_formats/boreholes/survey.py

@@ -1,15 +1,12 @@
-import warnings
-
+from dataclasses import dataclass
 from typing import Union, Hashable, Optional
 
 import pandas as pd
-from dataclasses import dataclass
-import numpy as np
-import xarray as xr
 
-from subsurface import optional_requirements
-from ...structs.unstructured_elements import LineSet
+from ._map_attrs_to_survey import combine_survey_and_attrs
+from ._survey_to_unstruct import data_frame_to_unstructured_data
 from ...structs.base_structures import UnstructuredData
+from ...structs.unstructured_elements import LineSet
 
 NUMBER_NODES = 30
 RADIUS = 10
@@ -39,7 +36,7 @@ class Survey:
         :return: A Survey object representing the input data.
 
         """
-        trajectories: UnstructuredData = _data_frame_to_unstructured_data(
+        trajectories: UnstructuredData = data_frame_to_unstructured_data(
             survey_df=_correct_angles(survey_df),
             attr_df=attr_df,
             number_nodes=number_nodes,
@@ -61,145 +58,11 @@ class Survey:
         return self.well_id_mapper.get(well_string_id, None)
 
     def update_survey_with_lith(self, lith: pd.DataFrame):
-        unstruct: UnstructuredData = _combine_survey_and_attrs(lith, self)
+        unstruct: UnstructuredData = combine_survey_and_attrs(lith, self.survey_trajectory, self.well_id_mapper)
         self.survey_trajectory.data = unstruct
 
     def update_survey_with_attr(self, attrs: pd.DataFrame):
-        self.survey_trajectory.data = _combine_survey_and_attrs(attrs, self)
-
-
-def _combine_survey_and_attr(lith: pd.DataFrame, survey: Survey) -> UnstructuredData:
-    pass
-
-
-def _combine_survey_and_attrs(attrs: pd.DataFrame, survey: Survey) -> UnstructuredData:
-    # Import moved to top for clarity and possibly avoiding repeated imports if called multiple times
-    from ...structs.base_structures._unstructured_data_constructor import raw_attributes_to_dict_data_arrays
-
-    # Accessing trajectory data more succinctly
-    trajectory: xr.DataArray = survey.survey_trajectory.data.data["vertex_attrs"]
-    # Ensure all columns in lith exist in new_attrs, if not, add them as NaN
-
-    new_attrs = _map_attrs_to_measured_depths(attrs, survey)
-
-    # Construct the final xarray dict without intermediate variable
-    points_attributes_xarray_dict = raw_attributes_to_dict_data_arrays(
-        default_attributes_name="vertex_attrs",
-        n_items=trajectory.shape[0],  # TODO: Can I look this on new_attrs to remove line 11?
-        dims=["points", "vertex_attr"],
-        raw_attributes=new_attrs
-    )
-
-    # Inline construction of UnstructuredData
-    return UnstructuredData.from_data_arrays_dict(
-        xarray_dict={
-                "vertex"      : survey.survey_trajectory.data.data["vertex"],
-                "cells"       : survey.survey_trajectory.data.data["cells"],
-                "vertex_attrs": points_attributes_xarray_dict["vertex_attrs"],
-                "cell_attrs"  : survey.survey_trajectory.data.data["cell_attrs"]
-        },
-        xarray_attributes=survey.survey_trajectory.data.data.attrs,
-        default_cells_attributes_name=survey.survey_trajectory.data.cells_attr_name,
-        default_points_attributes_name=survey.survey_trajectory.data.vertex_attr_name
-    )
-
-
-def _map_attrs_to_measured_depths(attrs: pd.DataFrame, survey: Survey) -> pd.DataFrame:
-    trajectory: xr.DataArray = survey.survey_trajectory.data.data["vertex_attrs"]
-    trajectory_well_id: xr.DataArray = trajectory.sel({'vertex_attr': 'well_id'})
-    measured_depths: np.ndarray = trajectory.sel({'vertex_attr': 'measured_depths'}).values.astype(np.float64)
-
-    # Start with a copy of the existing attributes DataFrame
-    new_attrs = survey.survey_trajectory.data.points_attributes.copy()
-    if 'component lith' in attrs.columns and 'lith_ids' not in attrs.columns:
-        # Factorize lith components directly in-place
-        attrs['lith_ids'], _ = pd.factorize(attrs['component lith'], use_na_sentinel=True)
-    else:
-        pass
-
-    # Add missing columns from attrs, preserving their dtypes
-    for col in attrs.columns.difference(new_attrs.columns):
-        new_attrs[col] = np.nan if pd.api.types.is_numeric_dtype(attrs[col]) else None
-
-    # Align well IDs between attrs and trajectory, perform interpolation, and map the attributes
-    # Loop dict
-    for survey_well_name in survey.well_id_mapper:
-        # Select rows corresponding to the current well ID
-
-        # use the well_id to get all the elements of attrs that have the well_id as index
-        if survey_well_name in attrs.index:
-            attrs_well = attrs.loc[[survey_well_name]]
-            # Proceed with processing attrs_well
-        else:
-            print(f"Well '{survey_well_name}' does not exist in the attributes DataFrame.")
-            continue
-
-        survey_well_id = survey.get_well_num_id(survey_well_name)
-        trajectory_well_mask = (trajectory_well_id == survey_well_id).values
-
-        # Apply mask to measured depths for the current well
-        well_measured_depths = measured_depths[trajectory_well_mask]
-
-        if "base" not in attrs_well.columns:
-            raise ValueError(f"Base column must be present in the file for well '{survey_well_name}'.")
-        elif "top" not in attrs_well.columns:
-            location_values_to_interpolate = attrs_well['base']
-        else:
-            location_values_to_interpolate = (attrs_well['top'] + attrs_well['base']) / 2
-
-        # Interpolation for each attribute column
-        for col in attrs_well.columns:
-            # Interpolate the attribute values based on the measured depths
-            if col in ['top', 'base', 'well_id']:
-                continue
-            attr_to_interpolate = attrs_well[col]
-            # make sure the attr_to_interpolate is not a string
-            if attr_to_interpolate.dtype == 'O' or isinstance(attr_to_interpolate.dtype, pd.CategoricalDtype): 
-                continue
-            if col in ['lith_ids', 'component lith']:
-                interp_kind = 'nearest'
-            else:
-                interp_kind = 'linear'
-
-            from scipy.interpolate import interp1d
-            interp_func = interp1d(
-                x=location_values_to_interpolate,
-                y=attr_to_interpolate,
-                bounds_error=False,
-                fill_value=np.nan,
-                kind=interp_kind
-            )
-
-            # Assign the interpolated values to the new_attrs DataFrame
-            vals = interp_func(well_measured_depths)
-            new_attrs.loc[trajectory_well_mask, col] = vals
-
-    return new_attrs
-
-
-def _map_attrs_to_measured_depths_(attrs: pd.DataFrame, new_attrs: pd.DataFrame, survey: Survey):
-    warnings.warn("This function is obsolete. Use _map_attrs_to_measured_depths instead.", DeprecationWarning)
-
-    trajectory: xr.DataArray = survey.survey_trajectory.data.data["vertex_attrs"]
-    well_ids: xr.DataArray = trajectory.sel({'vertex_attr': 'well_id'})
-    measured_depths: xr.DataArray = trajectory.sel({'vertex_attr': 'measured_depths'})
-
-    new_columns = attrs.columns.difference(new_attrs.columns)
-    new_attrs = pd.concat([new_attrs, pd.DataFrame(columns=new_columns)], axis=1)
-    for index, row in attrs.iterrows():
-        well_id = survey.get_well_num_id(index)
-        if well_id is None:
-            print(f'Well ID {index} not found in survey trajectory. Skipping lithology assignment.')
-
-        well_id_mask = well_ids == well_id
-
-        # TODO: Here we are going to need to interpolate
-
-        spatial_mask = ((measured_depths <= row['top']) & (measured_depths >= row['base']))
-        mask = well_id_mask & spatial_mask
-
-        new_attrs.loc[mask.values, attrs.columns] = row.values
-    return new_attrs
+        self.survey_trajectory.data = combine_survey_and_attrs(attrs, self.survey_trajectory, self.well_id_mapper)
 
 
 def _correct_angles(df: pd.DataFrame) -> pd.DataFrame:
@@ -221,160 +84,3 @@ def _correct_angles(df: pd.DataFrame) -> pd.DataFrame:
     df['azi'] = df['azi'].apply(correct_azimuth)
 
     return df
-
-
-def _data_frame_to_unstructured_data(survey_df: 'pd.DataFrame', number_nodes: int, attr_df: Optional['pd.DataFrame'] = None,
-                                     duplicate_attr_depths: bool = False) -> UnstructuredData:
-
-    wp = optional_requirements.require_wellpathpy()
-
-    cum_vertex: np.ndarray = np.empty((0, 3), dtype=np.float32)
-    cells: np.ndarray = np.empty((0, 2), dtype=np.int_)
-    cell_attr: pd.DataFrame = pd.DataFrame(columns=['well_id'], dtype=np.float32)
-    vertex_attr: pd.DataFrame = pd.DataFrame()
-
-    for e, (borehole_id, data) in enumerate(survey_df.groupby(level=0)):
-        dev = wp.deviation(
-            md=data['md'].values,
-            inc=data['inc'].values,
-            azi=data['azi'].values
-        )
-
-        md_min = dev.md.min()
-        md_max = dev.md.max()
-
-        attr_depths = _grab_depths_from_attr(
-            attr_df=attr_df,
-            borehole_id=borehole_id,
-            duplicate_attr_depths=duplicate_attr_depths,
-            md_max=md_max,
-            md_min=md_min
-        )
-
-        # Now combine attr_depths with depths
-        md_min = dev.md.min()
-        md_max = dev.md.max()
-        depths = np.linspace(md_min, md_max, number_nodes)
-        depths = np.union1d(depths, attr_depths)
-        depths.sort()
-
-        # Resample positions at depths
-        pos = dev.minimum_curvature().resample(depths=depths)
-        vertex_count = cum_vertex.shape[0]
-
-        this_well_vertex = np.vstack([pos.easting, pos.northing, pos.depth]).T
-        cum_vertex = np.vstack([cum_vertex, this_well_vertex])
-        measured_depths = _calculate_distances(array_of_vertices=this_well_vertex)
-
-        n_vertex_shift_0 = np.arange(0, len(pos.depth) - 1, dtype=np.int_)
-        n_vertex_shift_1 = np.arange(1, len(pos.depth), dtype=np.int_)
-        cell_per_well = np.vstack([n_vertex_shift_0, n_vertex_shift_1]).T + vertex_count
-        cells = np.vstack([cells, cell_per_well])
-
-        attribute_values = np.isin(depths, attr_depths)
-
-        vertex_attr_per_well = pd.DataFrame({
-                'well_id'        : [e] * len(pos.depth),
-                'measured_depths': measured_depths,
-                'is_attr_point'  : attribute_values,
-        })
-
-        vertex_attr = pd.concat([vertex_attr, vertex_attr_per_well], ignore_index=True)
-
-        # Add the id (e), to cell_attr
-        cell_attr = pd.concat([cell_attr, pd.DataFrame({'well_id': [e] * len(cell_per_well)})], ignore_index=True)
-
-    unstruct = UnstructuredData.from_array(
-        vertex=cum_vertex,
-        cells=cells.astype(int),
-        vertex_attr=vertex_attr.reset_index(drop=True),
-        cells_attr=cell_attr.reset_index(drop=True)
-    )
-
-    unstruct.data.attrs["well_id_mapper"] = {well_id: e for e, well_id in enumerate(survey_df.index.unique(level=0))}
-
-    return unstruct
-
-
-def _grab_depths_from_attr(
-        attr_df: pd.DataFrame,
-        borehole_id: Hashable,
-        duplicate_attr_depths: bool,
-        md_max: float,
-        md_min: float
-) -> np.ndarray:
-    # Initialize attr_depths and attr_labels as empty arrays
-    attr_depths = np.array([], dtype=float)
-    attr_labels = np.array([], dtype='<U4')  # Initialize labels for 'top' and 'base'
-
-    if attr_df is None or ("top" not in attr_df.columns and "base" not in attr_df.columns):
-        return attr_depths
-
-    try:
-        vals = attr_df.loc[borehole_id]
-
-        tops = np.array([], dtype=float)
-        bases = np.array([], dtype=float)
-
-        if 'top' in vals:
-            if isinstance(vals, pd.DataFrame):
-                tops = vals['top'].values.flatten()
-            else:
-                tops = np.array([vals['top']])
-            # Convert to float and remove NaNs
-            tops = tops.astype(float)
-            tops = tops[~np.isnan(tops)]
-            # Clip to within md range
-            tops = tops[(tops >= md_min) & (tops <= md_max)]
-
-        if 'base' in vals:
-            if isinstance(vals, pd.DataFrame):
-                bases = vals['base'].values.flatten()
-            else:
-                bases = np.array([vals['base']])
-            # Convert to float and remove NaNs
-            bases = bases.astype(float)
-            bases = bases[~np.isnan(bases)]
-            # Clip to within md range
-            bases = bases[(bases >= md_min) & (bases <= md_max)]
-
-        # Combine tops and bases into attr_depths with labels
-        attr_depths = np.concatenate((tops, bases))
-        attr_labels = np.array(['top'] * len(tops) + ['base'] * len(bases))
-
-        # Drop duplicates while preserving order
-        _, unique_indices = np.unique(attr_depths, return_index=True)
-        attr_depths = attr_depths[unique_indices]
-        attr_labels = attr_labels[unique_indices]
-
-    except KeyError:
-        # No attributes for this borehole_id or missing columns
-        attr_depths = np.array([], dtype=float)
-        attr_labels = np.array([], dtype='<U4')
-
-    # If duplicate_attr_depths is True, duplicate attr_depths with a tiny offset
-    if duplicate_attr_depths and len(attr_depths) > 0:
-        tiny_offset = (md_max - md_min) * 1e-6  # A tiny fraction of the depth range
-        # Create offsets: +tiny_offset for 'top', -tiny_offset for 'base'
-        offsets = np.where(attr_labels == 'top', tiny_offset, -tiny_offset)
-        duplicated_attr_depths = attr_depths + offsets
-        # Ensure the duplicated depths are within the md range
-        valid_indices = (duplicated_attr_depths >= md_min) & (duplicated_attr_depths <= md_max)
-        duplicated_attr_depths = duplicated_attr_depths[valid_indices]
-        # Original attribute depths
-        original_attr_depths = attr_depths
-        # Combine originals and duplicates
-        attr_depths = np.hstack([original_attr_depths, duplicated_attr_depths])
-
-    return attr_depths
-
-
-def _calculate_distances(array_of_vertices: np.ndarray) -> np.ndarray:
-    # Calculate the differences between consecutive points
-    differences = np.diff(array_of_vertices, axis=0)
-
-    # Calculate the Euclidean distance for each pair of consecutive points
-    distances = np.linalg.norm(differences, axis=1)
-    # Insert a 0 at the beginning to represent the starting point at the surface
-    measured_depths = np.insert(np.cumsum(distances), 0, 0)
-    return measured_depths

{subsurface_terra-2025.1.0rc14.dist-info → subsurface_terra-2025.1.0rc15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subsurface_terra
-Version: 2025.1.0rc14
+Version: 2025.1.0rc15
 Summary: Subsurface data types and utilities. This version is the one used by Terranigma Solutions. Please feel free to take anything in this repository for the original one.
 Home-page: https://softwareunderground.github.io/subsurface
 Author: Software Underground

{subsurface_terra-2025.1.0rc14.dist-info → subsurface_terra-2025.1.0rc15.dist-info}/RECORD

@@ -1,5 +1,5 @@
 subsurface/__init__.py,sha256=0D2rCUem3fiHsXFXXSmwheLiPS4cXxEdfWdFBj0b-cY,930
-subsurface/_version.py,sha256=6hCz-0xeTsPVqYirvA5x7rupXsfeGqd4ZcT7_v8NHgo,550
+subsurface/_version.py,sha256=oyGHFt2uSORzD3yojwTGuhpm_zC63z5TJljBVjwFw70,550
 subsurface/optional_requirements.py,sha256=Wg36RqxzPiLtN-3qSg5K9QVEeXCB0-EjSzHERAoO8EE,2883
 subsurface/api/__init__.py,sha256=E3R1fNn_d5XQdlZyjtzBcH_bYRzAvOc3xV38qFLqbZY,369
 subsurface/api/interfaces/__init__.py,sha256=rqUtJyMLicobcyhmr74TepjmUQAEmlazKT3vjV_n3aA,6
@@ -11,9 +11,11 @@ subsurface/core/geological_formats/__init__.py,sha256=jOyPsC3ZEMFljo9SGk0ym7cmBZ
 subsurface/core/geological_formats/fault.py,sha256=Zldf9VT4Gzo0NWe_UvBf5kOgxZtg2T9eWaWPqxeffWw,1547
 subsurface/core/geological_formats/boreholes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 subsurface/core/geological_formats/boreholes/_combine_trajectories.py,sha256=U5VribebcMAag0DOKnna983g1BXAGLKCddGra2g3Nos,5246
-subsurface/core/geological_formats/boreholes/boreholes.py,sha256=bWGEPMFHPVyGO8Kv3uBo9U8_MLXlEEkdraXx86eURJY,5364
+subsurface/core/geological_formats/boreholes/_map_attrs_to_survey.py,sha256=EH_gAY7d4v9Yyae4sEtWYQ7Ngb3_PN-TNszqjRjuEQ8,9013
+subsurface/core/geological_formats/boreholes/_survey_to_unstruct.py,sha256=kO-bOl60zHl2Xj0ESzKlzqNno4s4LBiEOmeziSX2HVI,6593
+subsurface/core/geological_formats/boreholes/boreholes.py,sha256=ZTZHjwihpw0a4nFpiO7O5lZI19I1JXMTKnGSohyURbE,6545
 subsurface/core/geological_formats/boreholes/collars.py,sha256=o1I8bS0XqWa2fS0n6XZVKXsuBHknXO2Z_5sdlFc_GAE,750
-subsurface/core/geological_formats/boreholes/survey.py,sha256=aaENR0ksT_lK0BYR7HL73KNZ44eo3Ag353xQdVcLOz0,16219
+subsurface/core/geological_formats/boreholes/survey.py,sha256=0aVLn0byYXRnqqdWpJlXEQzOYM-aZmQ6scnU-CrY6qI,3586
 subsurface/core/reader_helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 subsurface/core/reader_helpers/reader_unstruct.py,sha256=Lme1ano-dQrKhLCwrokcpKqa28DFxDaGAs3ub8MAHtY,397
 subsurface/core/reader_helpers/readers_data.py,sha256=Vewi8pqv-zooRIhffTM52eWZeP6l9MnHkD9LZj6c1LU,4995
@@ -89,8 +91,8 @@ subsurface/modules/writer/to_rex/material_encoder.py,sha256=zGlqF9X_Civ9VvtGwo-I
 subsurface/modules/writer/to_rex/mesh_encoder.py,sha256=6TBtJhYJEAMEBHxQkbweXrJO1jIUx1ClM8l5ajVCrLc,6443
 subsurface/modules/writer/to_rex/to_rex.py,sha256=njsm2d3e69pRVfF_TOC_hexvXPmgNTZdJvhbnXcvyIo,3800
 subsurface/modules/writer/to_rex/utils.py,sha256=HEpJ95LjHOK24ePpmLpPP5uFyv6i_kN3AWh031q-1Uc,379
-subsurface_terra-2025.1.0rc14.dist-info/licenses/LICENSE,sha256=GSXh9K5TZauM89BeGbYg07oST_HMhOTiZoEGaUeKBtA,11606
-subsurface_terra-2025.1.0rc14.dist-info/METADATA,sha256=RrT1uQXG_FQJNwVpkyTo1ozaLYC3bPVZr1mU_SulRHA,7094
-subsurface_terra-2025.1.0rc14.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-subsurface_terra-2025.1.0rc14.dist-info/top_level.txt,sha256=f32R_tUSf83CfkpB4vjv5m2XcD8TmDX9h7F4rnEXt5A,11
-subsurface_terra-2025.1.0rc14.dist-info/RECORD,,
+subsurface_terra-2025.1.0rc15.dist-info/licenses/LICENSE,sha256=GSXh9K5TZauM89BeGbYg07oST_HMhOTiZoEGaUeKBtA,11606
+subsurface_terra-2025.1.0rc15.dist-info/METADATA,sha256=3mtnSQiHih7wOyT6c-cZzFtrmA4uVUBFSEMAbttMKtQ,7094
+subsurface_terra-2025.1.0rc15.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+subsurface_terra-2025.1.0rc15.dist-info/top_level.txt,sha256=f32R_tUSf83CfkpB4vjv5m2XcD8TmDX9h7F4rnEXt5A,11
+subsurface_terra-2025.1.0rc15.dist-info/RECORD,,

{subsurface_terra-2025.1.0rc14.dist-info → subsurface_terra-2025.1.0rc15.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.1.0)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any