well-log-toolkit 0.1.148__tar.gz → 0.1.150__tar.gz

{well_log_toolkit-0.1.148 → well_log_toolkit-0.1.150}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.148
+Version: 0.1.150
 Summary: Fast LAS file processing with lazy loading and filtering for well log analysis
 Author-email: Kristian dF Kollsgård <kkollsg@gmail.com>
 License: MIT

{well_log_toolkit-0.1.148 → well_log_toolkit-0.1.150}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "well-log-toolkit"
-version = "0.1.148"
+version = "0.1.150"
 description = "Fast LAS file processing with lazy loading and filtering for well log analysis"
 readme = "README.md"
 requires-python = ">=3.9"

{well_log_toolkit-0.1.148 → well_log_toolkit-0.1.150}/well_log_toolkit/manager.py

@@ -1445,12 +1445,23 @@ class _ManagerPropertyProxy:
                             prop = prop.filter(filter_name, source=source_name)
 
                     # Compute sums_avg
-                    source_results[source_name] = prop.sums_avg(
+                    result = prop.sums_avg(
                         weighted=weighted,
                         arithmetic=arithmetic,
                         precision=precision
                     )
 
+                    # Add well-level thickness for this source if using filter_intervals
+                    if self._custom_intervals and result:
+                        well_thickness = 0.0
+                        for key, value in result.items():
+                            if isinstance(value, dict) and 'thickness' in value:
+                                well_thickness += value['thickness']
+                        if well_thickness > 0:
+                            result['thickness'] = round(well_thickness, precision)
+
+                    source_results[source_name] = result
+
                 except (PropertyNotFoundError, PropertyTypeError, AttributeError, KeyError, ValueError):
                     # Property or filter doesn't exist in this source, or filter isn't discrete - skip it
                     pass
@@ -1476,12 +1487,23 @@ class _ManagerPropertyProxy:
                     prop = prop.filter(filter_name)
 
             # Compute sums_avg
-            return prop.sums_avg(
+            result = prop.sums_avg(
                 weighted=weighted,
                 arithmetic=arithmetic,
                 precision=precision
             )
 
+            # Add well-level thickness (sum of all zone thicknesses) if using filter_intervals
+            if self._custom_intervals and result:
+                well_thickness = 0.0
+                for key, value in result.items():
+                    if isinstance(value, dict) and 'thickness' in value:
+                        well_thickness += value['thickness']
+                if well_thickness > 0:
+                    result['thickness'] = round(well_thickness, precision)
+
+            return result
+
         except PropertyNotFoundError as e:
             # Check if it's ambiguous (exists in multiple sources)
             if "ambiguous" in str(e).lower():
@@ -1512,6 +1534,16 @@ class _ManagerPropertyProxy:
                             arithmetic=arithmetic,
                             precision=precision
                         )
+
+                        # Add well-level thickness for this source if using filter_intervals
+                        if self._custom_intervals and result:
+                            well_thickness = 0.0
+                            for key, value in result.items():
+                                if isinstance(value, dict) and 'thickness' in value:
+                                    well_thickness += value['thickness']
+                            if well_thickness > 0:
+                                result['thickness'] = round(well_thickness, precision)
+
                         source_results[source_name] = result
 
                     except (PropertyNotFoundError, PropertyTypeError, AttributeError, KeyError, ValueError):
@@ -1632,7 +1664,7 @@ class _ManagerMultiPropertyProxy:
     PROPERTY_STATS = {'mean', 'median', 'mode', 'sum', 'std_dev', 'percentile', 'range'}
 
     # Stats that are common across properties (stay at group level)
-    COMMON_STATS = {'depth_range', 'samples', 'thickness', 'gross_thickness', 'thickness_fraction', 'calculation'}
+    COMMON_STATS = {'depth_range', 'samples', 'thickness', 'thickness_fraction', 'calculation'}
 
     def __init__(
         self,
@@ -1849,7 +1881,17 @@ class _ManagerMultiPropertyProxy:
             return self._merge_flat_results(property_results)
 
         # Merge results: nest property-specific stats, keep common stats at group level
-        return self._merge_property_results(property_results)
+        merged = self._merge_property_results(property_results)
+
+        # Add well-level thickness (sum of all zone thicknesses)
+        if self._custom_intervals and merged:
+            well_thickness = 0.0
+            for key, value in merged.items():
+                if isinstance(value, dict) and 'thickness' in value:
+                    well_thickness += value['thickness']
+            merged['thickness'] = round(well_thickness, 6)
+
+        return merged
 
     def _apply_filter_intervals(self, prop, well):
         """
@@ -3108,7 +3150,70 @@ class WellDataManager:
         ['well_12_3_2_B', 'well_12_3_2_A']
         """
         return list(self._wells.keys())
-    
+
+    @property
+    def saved_intervals(self) -> dict[str, list[str]]:
+        """
+        List saved interval names for all wells.
+
+        Returns
+        -------
+        dict[str, list[str]]
+            Dictionary mapping well names to their saved interval names
+
+        Examples
+        --------
+        >>> manager.saved_intervals
+        {'well_A': ['Reservoir_Zones', 'Slump_Zones'], 'well_B': ['Reservoir_Zones']}
+        """
+        result = {}
+        for well_name, well in self._wells.items():
+            if well.saved_intervals:
+                result[well_name] = well.saved_intervals
+        return result
+
+    def get_intervals(self, name: str) -> dict[str, list[dict]]:
+        """
+        Get saved filter intervals by name from all wells that have them.
+
+        Parameters
+        ----------
+        name : str
+            Name of the saved filter intervals
+
+        Returns
+        -------
+        dict[str, list[dict]]
+            Dictionary mapping well names to their interval definitions
+
+        Raises
+        ------
+        KeyError
+            If no wells have intervals with the given name
+
+        Examples
+        --------
+        >>> manager.get_intervals("Slump_Zones")
+        {'well_A': [{'name': 'Zone_A', 'top': 2500, 'base': 2650}],
+         'well_B': [{'name': 'Zone_A', 'top': 2600, 'base': 2750}]}
+        """
+        result = {}
+        for well_name, well in self._wells.items():
+            if name in well.saved_intervals:
+                result[well_name] = well.get_intervals(name)
+
+        if not result:
+            # Collect all available interval names for error message
+            all_names = set()
+            for well in self._wells.values():
+                all_names.update(well.saved_intervals)
+            raise KeyError(
+                f"No wells have saved intervals named '{name}'. "
+                f"Available: {sorted(all_names) if all_names else 'none'}"
+            )
+
+        return result
+
     def get_well(self, name: str) -> Well:
         """
         Get well by original or sanitized name.

{well_log_toolkit-0.1.148 → well_log_toolkit-0.1.150}/well_log_toolkit/property.py

@@ -11,6 +11,7 @@ from scipy.interpolate import interp1d
 from .exceptions import PropertyError, PropertyNotFoundError, PropertyTypeError, DepthAlignmentError
 from .statistics import (
     compute_intervals,
+    compute_zone_intervals,
     mean as stat_mean, sum as stat_sum, std as stat_std, percentile as stat_percentile
 )
 from .utils import filter_names
@@ -1429,8 +1430,8 @@ class Property(PropertyOperationsMixin):
         max_valid_depth = valid_depths.max()
 
         # Find boundaries that fall within the valid data range
-        # Filter to boundaries within valid range first
-        mask = (boundary_depths > min_valid_depth) & (boundary_depths < max_valid_depth)
+        # Filter to boundaries within valid range (inclusive on both ends)
+        mask = (boundary_depths >= min_valid_depth) & (boundary_depths <= max_valid_depth)
         potential_boundaries = boundary_depths[mask]
 
         if len(potential_boundaries) == 0:
@@ -1760,6 +1761,9 @@ class Property(PropertyOperationsMixin):
 
         This allows overlapping intervals where the same depths can
         contribute to multiple zones.
+
+        Uses zone-aware intervals that are truncated at zone boundaries to ensure
+        thickness is correctly attributed to each zone.
         """
         result = {}
 
@@ -1768,27 +1772,40 @@ class Property(PropertyOperationsMixin):
             top = float(interval['top'])
             base = float(interval['base'])
 
-            # Create mask for this interval (top <= depth < base)
-            interval_mask = (self.depth >= top) & (self.depth < base)
+            # Compute zone-aware intervals truncated at zone boundaries
+            zone_intervals = compute_zone_intervals(self.depth, top, base)
+
+            # Create mask based on zone intervals - includes any sample that
+            # contributes to this zone (even boundary samples with partial intervals)
+            interval_mask = zone_intervals > 0
+
+            # Calculate zone thickness (sum of valid intervals within zone)
+            valid_mask = interval_mask & ~np.isnan(self.values)
+            zone_thickness = float(np.sum(zone_intervals[valid_mask]))
 
             # If there are secondary properties, group within this interval
             if self.secondary_properties:
-                result[interval_name] = self._recursive_group(
+                interval_result = self._recursive_group(
                     0,
                     interval_mask,
                     weighted=weighted,
                     arithmetic=arithmetic,
-                    gross_thickness=gross_thickness,
-                    precision=precision
+                    gross_thickness=zone_thickness,  # Pass zone thickness as gross for children
+                    precision=precision,
+                    zone_intervals=zone_intervals
                 )
+                # Add zone-level thickness
+                interval_result['thickness'] = round(zone_thickness, precision)
+                result[interval_name] = interval_result
             else:
                 # No secondary properties, compute stats directly for interval
                 result[interval_name] = self._compute_stats(
                     interval_mask,
                     weighted=weighted,
                     arithmetic=arithmetic,
-                    gross_thickness=gross_thickness,
-                    precision=precision
+                    gross_thickness=zone_thickness,  # Use zone thickness for fraction calc
+                    precision=precision,
+                    zone_intervals=zone_intervals
                 )
 
         return result
@@ -1905,6 +1922,9 @@ class Property(PropertyOperationsMixin):
         This allows overlapping intervals where the same depths can
         contribute to multiple zones. Zone-level metadata (depth_range, thickness)
         is shown at the interval level, and fractions are relative to zone thickness.
+
+        Uses zone-aware intervals that are truncated at zone boundaries to ensure
+        thickness is correctly attributed to each zone.
         """
         result = {}
 
@@ -1913,13 +1933,16 @@ class Property(PropertyOperationsMixin):
             top = float(interval['top'])
             base = float(interval['base'])
 
-            # Create mask for this interval (top <= depth < base)
-            interval_mask = (self.depth >= top) & (self.depth < base)
+            # Compute zone-aware intervals truncated at zone boundaries
+            zone_intervals = compute_zone_intervals(self.depth, top, base)
+
+            # Create mask based on zone intervals - includes any sample that
+            # contributes to this zone (even boundary samples with partial intervals)
+            interval_mask = zone_intervals > 0
 
-            # Calculate zone thickness for fraction calculation
-            full_intervals = compute_intervals(self.depth)
+            # Calculate zone thickness using zone-aware intervals
             valid_mask = ~np.isnan(self.values) & interval_mask
-            zone_thickness = float(np.sum(full_intervals[valid_mask]))
+            zone_thickness = float(np.sum(zone_intervals[valid_mask]))
 
             # Get actual depth range within the interval (where we have data)
             if np.any(valid_mask):
@@ -1944,7 +1967,8 @@ class Property(PropertyOperationsMixin):
                     interval_mask,
                     gross_thickness=zone_thickness,  # Use zone thickness for fractions
                     precision=precision,
-                    include_depth_range=False  # Don't include depth_range per facies
+                    include_depth_range=False,  # Don't include depth_range per facies
+                    zone_intervals=zone_intervals  # Pass zone-aware intervals
                 )
             else:
                 # No secondary properties, compute stats directly for interval
@@ -1952,7 +1976,8 @@ class Property(PropertyOperationsMixin):
                     interval_mask,
                     gross_thickness=zone_thickness,  # Use zone thickness for fractions
                     precision=precision,
-                    include_depth_range=False  # Don't include depth_range per facies
+                    include_depth_range=False,  # Don't include depth_range per facies
+                    zone_intervals=zone_intervals  # Pass zone-aware intervals
                 )
 
             # Nest facies stats under 'facies' key for cleaner structure
@@ -1967,7 +1992,8 @@ class Property(PropertyOperationsMixin):
         mask: np.ndarray,
         gross_thickness: float,
         precision: int = 6,
-        include_depth_range: bool = True
+        include_depth_range: bool = True,
+        zone_intervals: Optional[np.ndarray] = None
     ) -> dict:
         """
         Recursively group discrete statistics by secondary properties.
@@ -1984,6 +2010,9 @@ class Property(PropertyOperationsMixin):
             Number of decimal places for rounding
         include_depth_range : bool, default True
             Whether to include depth_range in per-facies stats
+        zone_intervals : np.ndarray, optional
+            Pre-computed zone-aware intervals truncated at zone boundaries.
+            If None, computes intervals using standard midpoint method.
 
         Returns
         -------
@@ -1992,7 +2021,7 @@ class Property(PropertyOperationsMixin):
         """
         if filter_idx >= len(self.secondary_properties):
             # Base case: compute discrete statistics for this group
-            return self._compute_discrete_stats(mask, gross_thickness, precision, include_depth_range)
+            return self._compute_discrete_stats(mask, gross_thickness, precision, include_depth_range, zone_intervals)
 
         # Get unique values for current filter
         current_filter = self.secondary_properties[filter_idx]
@@ -2002,12 +2031,16 @@ class Property(PropertyOperationsMixin):
 
         if len(unique_vals) == 0:
             # No valid values, return stats for current mask
-            return self._compute_discrete_stats(mask, gross_thickness, precision, include_depth_range)
+            return self._compute_discrete_stats(mask, gross_thickness, precision, include_depth_range, zone_intervals)
 
         # Group by each unique value
         depth_array = self.depth
         values_array = self.values
-        full_intervals = compute_intervals(depth_array)
+        # Use zone intervals if provided, otherwise compute on full array
+        if zone_intervals is not None:
+            full_intervals = zone_intervals
+        else:
+            full_intervals = compute_intervals(depth_array)
 
         result = {}
         for val in unique_vals:
@@ -2038,7 +2071,7 @@ class Property(PropertyOperationsMixin):
                 key = f"{current_filter.name}_{val:.2f}"
 
             result[key] = self._recursive_discrete_group(
-                filter_idx + 1, sub_mask, group_thickness, precision, include_depth_range
+                filter_idx + 1, sub_mask, group_thickness, precision, include_depth_range, zone_intervals
             )
 
         return result
@@ -2048,7 +2081,8 @@ class Property(PropertyOperationsMixin):
         mask: np.ndarray,
         gross_thickness: float,
         precision: int = 6,
-        include_depth_range: bool = True
+        include_depth_range: bool = True,
+        zone_intervals: Optional[np.ndarray] = None
     ) -> dict:
         """
         Compute categorical statistics for discrete property values.
@@ -2064,6 +2098,9 @@ class Property(PropertyOperationsMixin):
         include_depth_range : bool, default True
             Whether to include depth_range in per-facies stats.
             Set to False when using filter_intervals (depth_range shown at zone level).
+        zone_intervals : np.ndarray, optional
+            Pre-computed zone-aware intervals truncated at zone boundaries.
+            If None, computes intervals using standard midpoint method.
 
         Returns
         -------
@@ -2077,9 +2114,12 @@ class Property(PropertyOperationsMixin):
         values = values_array[mask]
         depths = depth_array[mask]
 
-        # Compute intervals on full array then mask
-        full_intervals = compute_intervals(depth_array)
-        intervals = full_intervals[mask]
+        # Use zone intervals if provided, otherwise compute on full array
+        if zone_intervals is not None:
+            intervals = zone_intervals[mask]
+        else:
+            full_intervals = compute_intervals(depth_array)
+            intervals = full_intervals[mask]
 
         # Find unique discrete values
         valid_mask_local = ~np.isnan(values)
@@ -2132,7 +2172,8 @@ class Property(PropertyOperationsMixin):
         weighted: bool,
         arithmetic: bool,
         gross_thickness: float,
-        precision: int = 6
+        precision: int = 6,
+        zone_intervals: Optional[np.ndarray] = None
     ) -> dict:
         """
         Recursively group by secondary properties.
@@ -2151,6 +2192,9 @@ class Property(PropertyOperationsMixin):
             Total gross thickness for fraction calculation
         precision : int, default 6
             Number of decimal places for rounding
+        zone_intervals : np.ndarray, optional
+            Pre-computed zone-aware intervals truncated at zone boundaries.
+            If None, computes intervals using standard midpoint method.
 
         Returns
         -------
@@ -2159,7 +2203,7 @@ class Property(PropertyOperationsMixin):
         """
         if filter_idx >= len(self.secondary_properties):
             # Base case: compute statistics for this group
-            return self._compute_stats(mask, weighted, arithmetic, gross_thickness, precision)
+            return self._compute_stats(mask, weighted, arithmetic, gross_thickness, precision, zone_intervals)
 
         # Get unique values for current filter
         current_filter = self.secondary_properties[filter_idx]
@@ -2170,14 +2214,18 @@ class Property(PropertyOperationsMixin):
 
         if len(unique_vals) == 0:
             # No valid values, return stats for current mask
-            return self._compute_stats(mask, weighted, arithmetic, gross_thickness, precision)
+            return self._compute_stats(mask, weighted, arithmetic, gross_thickness, precision, zone_intervals)
 
         # Calculate parent thickness BEFORE subdividing
         # This becomes the gross_thickness for all child groups
         # Cache property access to avoid overhead
         depth_array = self.depth
         values_array = self.values
-        parent_intervals = compute_intervals(depth_array)
+        # Use zone intervals if provided, otherwise compute on full array
+        if zone_intervals is not None:
+            parent_intervals = zone_intervals
+        else:
+            parent_intervals = compute_intervals(depth_array)
         parent_valid = mask & ~np.isnan(values_array)
         parent_thickness = float(np.sum(parent_intervals[parent_valid]))
 
@@ -2212,7 +2260,7 @@ class Property(PropertyOperationsMixin):
                 key = f"{current_filter.name}_{val:.2f}"
 
             result[key] = self._recursive_group(
-                filter_idx + 1, sub_mask, weighted, arithmetic, parent_thickness, precision
+                filter_idx + 1, sub_mask, weighted, arithmetic, parent_thickness, precision, zone_intervals
             )
 
         return result
@@ -2223,7 +2271,8 @@ class Property(PropertyOperationsMixin):
         weighted: bool = True,
         arithmetic: bool = False,
         gross_thickness: float = 0.0,
-        precision: int = 6
+        precision: int = 6,
+        zone_intervals: Optional[np.ndarray] = None
     ) -> dict:
         """
         Compute statistics for values selected by mask.
@@ -2244,6 +2293,9 @@ class Property(PropertyOperationsMixin):
             Total gross thickness for fraction calculation
         precision : int, default 6
             Number of decimal places for rounding
+        zone_intervals : np.ndarray, optional
+            Pre-computed zone-aware intervals truncated at zone boundaries.
+            If None, computes intervals using standard midpoint method.
 
         Returns
         -------
@@ -2263,12 +2315,17 @@ class Property(PropertyOperationsMixin):
         values = values_array[mask]
         valid = values[~np.isnan(values)]
 
-        # Compute depth intervals on FULL depth array first, then mask
-        # This is critical! Intervals must be computed on full grid so that
-        # zone boundary samples get correct weights based on their neighbors
-        # in the full sequence, not just within their zone.
-        full_intervals = compute_intervals(depth_array)
-        intervals = full_intervals[mask]
+        # Use zone intervals if provided, otherwise compute on full array
+        # Zone intervals are truncated at zone boundaries for accurate thickness
+        if zone_intervals is not None:
+            intervals = zone_intervals[mask]
+        else:
+            # Compute depth intervals on FULL depth array first, then mask
+            # This is critical! Intervals must be computed on full grid so that
+            # zone boundary samples get correct weights based on their neighbors
+            # in the full sequence, not just within their zone.
+            full_intervals = compute_intervals(depth_array)
+            intervals = full_intervals[mask]
         valid_mask_local = ~np.isnan(values)
         valid_intervals = intervals[valid_mask_local]
 
@@ -2366,7 +2423,6 @@ class Property(PropertyOperationsMixin):
             'depth_range': _round_value(depth_range_dict),
             'samples': int(len(valid)),
             'thickness': round(thickness, precision),
-            'gross_thickness': round(gross_thickness, precision),
             'thickness_fraction': round(fraction, precision),
             'calculation': calc_method,
         }

{well_log_toolkit-0.1.148 → well_log_toolkit-0.1.150}/well_log_toolkit/statistics.py

@@ -61,6 +61,83 @@ def compute_intervals(depth: np.ndarray) -> np.ndarray:
     return intervals
 
 
+def compute_zone_intervals(
+    depth: np.ndarray,
+    top: float,
+    base: float
+) -> np.ndarray:
+    """
+    Compute depth intervals truncated to zone boundaries.
+
+    Uses the midpoint method but truncates intervals at zone boundaries
+    to ensure thickness is correctly attributed to each zone.
+
+    Parameters
+    ----------
+    depth : np.ndarray
+        Depth values (must be sorted ascending)
+    top : float
+        Zone top depth (inclusive)
+    base : float
+        Zone base depth (exclusive)
+
+    Returns
+    -------
+    np.ndarray
+        Interval thickness for each depth point, truncated to zone boundaries.
+        Points outside the zone have zero interval.
+
+    Examples
+    --------
+    >>> depth = np.array([2708.0, 2708.3, 2708.4, 2708.6])
+    >>> # Zone from 2708.0 to 2708.4
+    >>> compute_zone_intervals(depth, 2708.0, 2708.4)
+    array([0.15, 0.2, 0.05, 0.0])
+
+    The intervals are truncated at zone boundary 2708.4:
+    - 2708.0: from 2708.0 to midpoint(2708.0, 2708.3)=2708.15 = 0.15m
+    - 2708.3: from 2708.15 to midpoint(2708.3, 2708.4)=2708.35 = 0.2m
+    - 2708.4: from 2708.35 to 2708.4 (zone boundary) = 0.05m (truncated)
+    - 2708.6: outside zone = 0.0m
+    """
+    if len(depth) == 0:
+        return np.array([])
+
+    if len(depth) == 1:
+        # Single point - check if it's in the zone
+        if top <= depth[0] < base:
+            return np.array([base - top])
+        return np.array([0.0])
+
+    zone_intervals = np.zeros(len(depth))
+
+    for i in range(len(depth)):
+        d = depth[i]
+
+        # Calculate midpoint bounds for this sample
+        if i == 0:
+            lower_bound = d - (depth[1] - d) / 2.0  # Mirror first interval
+        else:
+            lower_bound = (depth[i - 1] + d) / 2.0
+
+        if i == len(depth) - 1:
+            upper_bound = d + (d - depth[-2]) / 2.0  # Mirror last interval
+        else:
+            upper_bound = (d + depth[i + 1]) / 2.0
+
+        # Truncate to zone boundaries
+        effective_lower = max(lower_bound, top)
+        effective_upper = min(upper_bound, base)
+
+        # Only count if there's overlap with the zone
+        if effective_upper > effective_lower:
+            zone_intervals[i] = effective_upper - effective_lower
+        else:
+            zone_intervals[i] = 0.0
+
+    return zone_intervals
+
+
 def mean(
     values: np.ndarray,
     weights: Optional[np.ndarray] = None,

{well_log_toolkit-0.1.148 → well_log_toolkit-0.1.150}/well_log_toolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.148
+Version: 0.1.150
 Summary: Fast LAS file processing with lazy loading and filtering for well log analysis
 Author-email: Kristian dF Kollsgård <kkollsg@gmail.com>
 License: MIT