subsurface-terra 2025.1.0rc13__tar.gz → 2025.1.0rc15__tar.gz

{subsurface_terra-2025.1.0rc13 → subsurface_terra-2025.1.0rc15}/.teamcity/Subsurface/buildTypes/Subsurface_ReleaseSubsurface_2.xml

@@ -1,9 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<build-type xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" uuid="c15fb876-7044-47cd-a3b0-676767e4ca63" xsi:noNamespaceSchemaLocation="https://www.jetbrains.com/teamcity/schemas/2021.1/project-config.xsd">
+<build-type xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" uuid="c15fb876-7044-47cd-a3b0-676767e4ca63" xsi:noNamespaceSchemaLocation="https://www.jetbrains.com/teamcity/schemas/2025.3/project-config.xsd">
   <name>Release Subsurface</name>
   <description />
   <settings ref="ReleasePythonPackage">
-    <parameters />
+    <parameters>
+      <param name="env.org/repo" value="terranigma-solutions/subsurface" />
+    </parameters>
     <build-runners order="Git_Tagging, Build, Push_to_PyPi, Push_To_GitHub">
       <runner id="Build" name="Build" type="simpleRunner">
         <parameters>
@@ -18,20 +20,10 @@ python -m build]]></param>
           <param name="use.custom.script" value="true" />
         </parameters>
       </runner>
-      <runner id="Push_To_GitHub" name="Push To GitHub" type="simpleRunner">
-        <parameters>
-          <param name="script.content" value="gh release create %env.PACKAGE_VERSION% dist/*  --notes &quot;Release notes here&quot; --repo terranigma-solutions/subsurface" />
-          <param name="teamcity.step.mode" value="default" />
-          <param name="use.custom.script" value="true" />
-        </parameters>
-      </runner>
     </build-runners>
     <vcs-settings>
       <vcs-entry-ref root-id="Subsurface_HttpsGithubComTerranigmaSolutionsSubsurfaceRefsHeadsMain1" />
     </vcs-settings>
-    <requirements />
-    <build-triggers />
-    <cleanup />
   </settings>
 </build-type>
 

{subsurface_terra-2025.1.0rc13/subsurface_terra.egg-info → subsurface_terra-2025.1.0rc15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subsurface_terra
-Version: 2025.1.0rc13
+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.0rc13 → subsurface_terra-2025.1.0rc15}/subsurface/_version.py

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

subsurface_terra-2025.1.0rc15/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_terra-2025.1.0rc15/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_terra-2025.1.0rc13 → subsurface_terra-2025.1.0rc15}/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,10 +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 = {}
-        for lith, group in merged_df.groupby('component lith'):
+        group = merged_df.groupby(group_by)
+
+        if group.ngroups == 0:
+            raise ValueError("No components found")
+        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_terra-2025.1.0rc15/subsurface/core/geological_formats/boreholes/survey.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass
+from typing import Union, Hashable, Optional
+
+import pandas as pd
+
+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
+
+
+@dataclass
+class Survey:
+    ids: list[str]
+    survey_trajectory: LineSet
+    well_id_mapper: dict[str, int] = None  #: This is following the order of the survey csv that can be different that the collars
+
+    @property
+    def id_to_well_id(self):
+        # Reverse the well_id_mapper dictionary to map IDs to well names
+        id_to_well_name_mapper = {v: k for k, v in self.well_id_mapper.items()}
+        return id_to_well_name_mapper
+
+    @classmethod
+    def from_df(cls, survey_df: 'pd.DataFrame', attr_df: Optional['pd.DataFrame'] = None, number_nodes: Optional[int] = NUMBER_NODES,
+                duplicate_attr_depths: bool = False) -> 'Survey':
+        """
+        Create a Survey object from two DataFrames containing survey and attribute data.
+
+        :param survey_df: DataFrame containing survey data.
+        :param attr_df: DataFrame containing attribute data. This is used to make sure the raw data is perfectly aligned.
+        :param number_nodes: Optional parameter specifying the number of nodes.
+        :return: A Survey object representing the input data.
+
+        """
+        trajectories: UnstructuredData = data_frame_to_unstructured_data(
+            survey_df=_correct_angles(survey_df),
+            attr_df=attr_df,
+            number_nodes=number_nodes,
+            duplicate_attr_depths=duplicate_attr_depths
+        )
+        # Grab the unique ids
+        unique_ids = trajectories.points_attributes["well_id"].unique()
+
+        return cls(
+            ids=unique_ids,
+            survey_trajectory=LineSet(data=trajectories, radius=RADIUS),
+            well_id_mapper=trajectories.data.attrs["well_id_mapper"]
+        )
+
+    def get_well_string_id(self, well_id: int) -> str:
+        return self.ids[well_id]
+
+    def get_well_num_id(self, well_string_id: Union[str, Hashable]) -> int:
+        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.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.survey_trajectory, self.well_id_mapper)
+
+
+def _correct_angles(df: pd.DataFrame) -> pd.DataFrame:
+    def correct_inclination(inc: float) -> float:
+        if inc < 0:
+            inc = inc % 360  # Normalize to 0-360 range first if negative
+        if 0 <= inc <= 180:
+            # add or subtract a very small number to make sure that 0 or 180 are never possible
+            return inc + 1e-10 if inc == 0 else inc - 1e-10
+        elif 180 < inc < 360:
+            return 360 - inc  # Reflect angles greater than 180 back into the 0-180 range
+        else:
+            raise ValueError(f'Inclination value {inc} is out of the expected range of 0 to 360 degrees')
+
+    def correct_azimuth(azi: float) -> float:
+        return azi % 360  # Normalize azimuth to 0-360 range
+
+    df['inc'] = df['inc'].apply(correct_inclination)
+    df['azi'] = df['azi'].apply(correct_azimuth)
+
+    return df

{subsurface_terra-2025.1.0rc13 → subsurface_terra-2025.1.0rc15/subsurface_terra.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: subsurface_terra
-Version: 2025.1.0rc13
+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.0rc13 → subsurface_terra-2025.1.0rc15}/subsurface_terra.egg-info/SOURCES.txt

@@ -33,6 +33,8 @@ subsurface/core/geological_formats/__init__.py
 subsurface/core/geological_formats/fault.py
 subsurface/core/geological_formats/boreholes/__init__.py
 subsurface/core/geological_formats/boreholes/_combine_trajectories.py
+subsurface/core/geological_formats/boreholes/_map_attrs_to_survey.py
+subsurface/core/geological_formats/boreholes/_survey_to_unstruct.py
 subsurface/core/geological_formats/boreholes/boreholes.py
 subsurface/core/geological_formats/boreholes/collars.py
 subsurface/core/geological_formats/boreholes/survey.py