well-log-toolkit 0.1.143__py3-none-any.whl → 0.1.145__py3-none-any.whl

well_log_toolkit/property.py

@@ -1789,7 +1789,11 @@ class Property(PropertyOperationsMixin):
 
         return result
 
-    def discrete_summary(self, precision: int = 6) -> dict:
+    def discrete_summary(
+        self,
+        precision: int = 6,
+        skip: Optional[list[str]] = None
+    ) -> dict:
         """
         Compute summary statistics for discrete/categorical properties.
 
@@ -1801,6 +1805,9 @@ class Property(PropertyOperationsMixin):
         ----------
         precision : int, default 6
             Number of decimal places for rounding numeric results
+        skip : list[str], optional
+            List of field names to exclude from the output.
+            Valid fields: 'code', 'count', 'thickness', 'fraction', 'depth_range'
 
         Returns
         -------
@@ -1808,8 +1815,7 @@ class Property(PropertyOperationsMixin):
             Nested dictionary with statistics for each discrete value.
             If secondary properties (filters) exist, the structure is hierarchical.
 
-            For each discrete value, includes:
-            - label: Human-readable name (if labels defined)
+            For each discrete value, includes (unless skipped):
             - code: Numeric code for this category
             - count: Number of samples with this value
             - thickness: Total depth interval (meters) for this category
@@ -1824,6 +1830,10 @@ class Property(PropertyOperationsMixin):
         >>> # {'Sand': {'code': 1, 'count': 150, 'thickness': 25.5, 'fraction': 0.45, ...},
         >>> #  'Shale': {'code': 2, 'count': 180, 'thickness': 30.8, 'fraction': 0.55, ...}}
 
+        >>> # Skip certain fields
+        >>> stats = facies.discrete_summary(skip=['code', 'count'])
+        >>> # {'Sand': {'thickness': 25.5, 'fraction': 0.45}, ...}
+
         >>> # Grouped by zones
         >>> filtered = facies.filter('Well_Tops')
         >>> stats = filtered.discrete_summary()
@@ -1842,26 +1852,43 @@ class Property(PropertyOperationsMixin):
         # Check for custom intervals (from filter_intervals)
         # These are processed independently, allowing overlaps
         if hasattr(self, '_custom_intervals') and self._custom_intervals:
-            return self._compute_discrete_stats_by_intervals(
+            result = self._compute_discrete_stats_by_intervals(
                 gross_thickness=gross_thickness,
                 precision=precision
             )
-
-        if not self.secondary_properties:
+        elif not self.secondary_properties:
             # No filters, compute stats for all discrete values
-            return self._compute_discrete_stats(
+            result = self._compute_discrete_stats(
+                np.ones(len(self.depth), dtype=bool),
+                gross_thickness=gross_thickness,
+                precision=precision
+            )
+        else:
+            # Build hierarchical grouping
+            result = self._recursive_discrete_group(
+                0,
                 np.ones(len(self.depth), dtype=bool),
                 gross_thickness=gross_thickness,
                 precision=precision
             )
 
-        # Build hierarchical grouping
-        return self._recursive_discrete_group(
-            0,
-            np.ones(len(self.depth), dtype=bool),
-            gross_thickness=gross_thickness,
-            precision=precision
-        )
+        # Remove skipped fields from output
+        if skip:
+            result = self._remove_keys_recursive(result, skip)
+
+        return result
+
+    def _remove_keys_recursive(self, d: dict, keys_to_remove: list[str]) -> dict:
+        """Recursively remove specified keys from nested dicts."""
+        result = {}
+        for key, value in d.items():
+            if key in keys_to_remove:
+                continue
+            if isinstance(value, dict):
+                result[key] = self._remove_keys_recursive(value, keys_to_remove)
+            else:
+                result[key] = value
+        return result
 
     def _compute_discrete_stats_by_intervals(
         self,
@@ -1872,7 +1899,8 @@ class Property(PropertyOperationsMixin):
         Compute discrete statistics for each custom interval independently.
 
         This allows overlapping intervals where the same depths can
-        contribute to multiple zones.
+        contribute to multiple zones. Zone-level metadata (depth_range, thickness)
+        is shown at the interval level, and fractions are relative to zone thickness.
         """
         result = {}
 
@@ -1884,22 +1912,49 @@ class Property(PropertyOperationsMixin):
             # Create mask for this interval (top <= depth < base)
             interval_mask = (self.depth >= top) & (self.depth < base)
 
+            # Calculate zone thickness for fraction calculation
+            full_intervals = compute_intervals(self.depth)
+            valid_mask = ~np.isnan(self.values) & interval_mask
+            zone_thickness = float(np.sum(full_intervals[valid_mask]))
+
+            # Get actual depth range within the interval (where we have data)
+            if np.any(valid_mask):
+                zone_depths = self.depth[valid_mask]
+                zone_depth_range = {
+                    'min': round(float(np.min(zone_depths)), precision),
+                    'max': round(float(np.max(zone_depths)), precision)
+                }
+            else:
+                zone_depth_range = {'min': top, 'max': base}
+
+            # Build interval result with zone-level metadata
+            interval_result = {
+                'depth_range': zone_depth_range,
+                'thickness': round(zone_thickness, precision)
+            }
+
             # If there are secondary properties, group within this interval
             if self.secondary_properties:
-                result[interval_name] = self._recursive_discrete_group(
+                facies_stats = self._recursive_discrete_group(
                     0,
                     interval_mask,
-                    gross_thickness=gross_thickness,
-                    precision=precision
+                    gross_thickness=zone_thickness,  # Use zone thickness for fractions
+                    precision=precision,
+                    include_depth_range=False  # Don't include depth_range per facies
                 )
             else:
                 # No secondary properties, compute stats directly for interval
-                result[interval_name] = self._compute_discrete_stats(
+                facies_stats = self._compute_discrete_stats(
                     interval_mask,
-                    gross_thickness=gross_thickness,
-                    precision=precision
+                    gross_thickness=zone_thickness,  # Use zone thickness for fractions
+                    precision=precision,
+                    include_depth_range=False  # Don't include depth_range per facies
                 )
 
+            # Nest facies stats under 'facies' key for cleaner structure
+            interval_result['facies'] = facies_stats
+            result[interval_name] = interval_result
+
         return result
 
     def _recursive_discrete_group(
@@ -1907,7 +1962,8 @@ class Property(PropertyOperationsMixin):
         filter_idx: int,
         mask: np.ndarray,
         gross_thickness: float,
-        precision: int = 6
+        precision: int = 6,
+        include_depth_range: bool = True
     ) -> dict:
         """
         Recursively group discrete statistics by secondary properties.
@@ -1922,6 +1978,8 @@ class Property(PropertyOperationsMixin):
             Total gross thickness for fraction calculation
         precision : int, default 6
             Number of decimal places for rounding
+        include_depth_range : bool, default True
+            Whether to include depth_range in per-facies stats
 
         Returns
         -------
@@ -1930,7 +1988,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)
+            return self._compute_discrete_stats(mask, gross_thickness, precision, include_depth_range)
 
         # Get unique values for current filter
         current_filter = self.secondary_properties[filter_idx]
@@ -1940,7 +1998,7 @@ 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)
+            return self._compute_discrete_stats(mask, gross_thickness, precision, include_depth_range)
 
         # Group by each unique value
         depth_array = self.depth
@@ -1976,7 +2034,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
+                filter_idx + 1, sub_mask, group_thickness, precision, include_depth_range
             )
 
         return result
@@ -1985,7 +2043,8 @@ class Property(PropertyOperationsMixin):
         self,
         mask: np.ndarray,
         gross_thickness: float,
-        precision: int = 6
+        precision: int = 6,
+        include_depth_range: bool = True
     ) -> dict:
         """
         Compute categorical statistics for discrete property values.
@@ -1998,12 +2057,15 @@ class Property(PropertyOperationsMixin):
             Total gross thickness for fraction calculation
         precision : int, default 6
             Number of decimal places for rounding
+        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).
 
         Returns
         -------
         dict
             Dictionary with stats for each discrete value:
-            {value_label: {code, count, thickness, fraction, depth_range}}
+            {value_label: {code, count, thickness, fraction, [depth_range]}}
         """
         values_array = self.values
         depth_array = self.depth
@@ -2036,27 +2098,24 @@ class Property(PropertyOperationsMixin):
             count = int(np.sum(val_mask))
             fraction = thickness / gross_thickness if gross_thickness > 0 else 0.0
 
-            # Determine the key and label
+            # Determine the key (use label if available, otherwise name_code)
             int_val = int(val)
             if self.labels is not None and int_val in self.labels:
                 key = self.labels[int_val]
-                label = self.labels[int_val]
             else:
                 key = f"{self.name}_{int_val}"
-                label = None
 
             stats = {
                 'code': int_val,
                 'count': count,
                 'thickness': round(thickness, precision),
-                'fraction': round(fraction, precision),
-                'depth_range': {
+                'fraction': round(fraction, precision)
+            }
+            if include_depth_range:
+                stats['depth_range'] = {
                     'min': round(float(np.min(val_depths)), precision),
                     'max': round(float(np.max(val_depths)), precision)
                 }
-            }
-            if label is not None:
-                stats['label'] = label
 
             result[key] = stats
 

{well_log_toolkit-0.1.143.dist-info → well_log_toolkit-0.1.145.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.143
+Version: 0.1.145
 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
@@ -288,6 +288,74 @@ stats = well.PHIE.filter('Zone').filter('Facies').sums_avg()
 - `samples` - Number of valid measurements
 - `range`, `depth_range` - Min/max values and depths
 
+### Custom Interval Filtering
+
+Define custom depth intervals without needing a discrete property in the well:
+
+```python
+# Define intervals with name, top, and base
+intervals = [
+    {"name": "Zone_A", "top": 2500, "base": 2650},
+    {"name": "Zone_B", "top": 2650, "base": 2800}
+]
+
+# Use with sums_avg or discrete_summary
+stats = well.PHIE.filter_intervals(intervals).sums_avg()
+# → {'Zone_A': {'mean': 0.18, ...}, 'Zone_B': {'mean': 0.21, ...}}
+
+facies_stats = well.Facies.filter_intervals(intervals).discrete_summary()
+```
+
+**Overlapping intervals** are supported - each interval is calculated independently:
+
+```python
+# These intervals overlap at 2600-2700m
+intervals = [
+    {"name": "Full_Reservoir", "top": 2500, "base": 2800},
+    {"name": "Upper_Section", "top": 2500, "base": 2700}
+]
+# Depths 2500-2700 are counted in BOTH zones
+stats = well.PHIE.filter_intervals(intervals).sums_avg()
+```
+
+**Save intervals for reuse:**
+
+```python
+# Save intervals to the well
+well.PHIE.filter_intervals(intervals, save="Reservoir_Zones")
+
+# Use saved intervals by name
+stats = well.PHIE.filter_intervals("Reservoir_Zones").sums_avg()
+
+# List saved intervals
+print(well.saved_intervals)  # ['Reservoir_Zones']
+
+# Retrieve intervals
+intervals = well.get_intervals("Reservoir_Zones")
+```
+
+**Save different intervals for multiple wells:**
+
+```python
+# Define well-specific intervals
+manager.well_A.PHIE.filter_intervals({
+    "Well_A": [{"name": "Zone_A", "top": 2500, "base": 2700}],
+    "Well_B": [{"name": "Zone_A", "top": 2600, "base": 2800}]
+}, save="My_Zones")
+
+# Both wells now have "My_Zones" saved with their respective intervals
+```
+
+**Chain with other filters:**
+
+```python
+# Combine custom intervals with property filters
+stats = well.PHIE.filter_intervals(intervals).filter("NetFlag").sums_avg()
+# → {'Zone_A': {'Net': {...}, 'NonNet': {...}}, 'Zone_B': {...}}
+```
+
+> **💡 Key Difference:** Unlike `.filter('Well_Tops')` where each depth belongs to exactly one zone, `filter_intervals()` allows overlapping intervals where the same depths can contribute to multiple zones.
+
 ### Property Operations
 
 Create computed properties using natural mathematical syntax:

{well_log_toolkit-0.1.143.dist-info → well_log_toolkit-0.1.145.dist-info}/RECORD

@@ -3,13 +3,13 @@ well_log_toolkit/exceptions.py,sha256=X_fzC7d4yaBFO9Vx74dEIB6xmI9Agi6_bTU3MPxn6k
 well_log_toolkit/las_file.py,sha256=Tj0mRfX1aX2s6uug7BBlY1m_mu3G50EGxHGzD0eEedE,53876
 well_log_toolkit/manager.py,sha256=VIARJLkYhxqxgTqfVfAAZU6AVsAPkQWPOUE6RNGnIdY,110558
 well_log_toolkit/operations.py,sha256=z8j8fGBOwoJGUQFy-Vawjq9nm3OD_dUt0oaNh8yuG7o,18515
-well_log_toolkit/property.py,sha256=EGT7SRXM4V0freWbyPBWyP7-w08S_iGcRPs1lPiXQ2c,97868
+well_log_toolkit/property.py,sha256=O5Ti5ahWV3CTlBLGZ-ntEIed6GGyzsxnyO_EbYrNLP0,100752
 well_log_toolkit/regression.py,sha256=JDcRxaODJnFikAdPJyTq8eUV7iY0vCDmvnGufqlojxs,31625
 well_log_toolkit/statistics.py,sha256=_huPMbv2H3o9ezunjEM94mJknX5wPK8V4nDv2lIZZRw,16814
 well_log_toolkit/utils.py,sha256=O2KPq4htIoUlL74V2zKftdqqTjRfezU9M-568zPLme0,6866
 well_log_toolkit/visualization.py,sha256=nnpmFmbj44TbP0fsnLMR1GaKRkqKCEpI6Fd8Cp0oqBc,204716
 well_log_toolkit/well.py,sha256=n6XfaGSjGtyXCIaAr0ytslIK0DMUY_fSPQ_VCqj8jaU,106173
-well_log_toolkit-0.1.143.dist-info/METADATA,sha256=7JbOxO2QEPh0KKSS-U03-U94O7DKZTYk96laFMOj--Q,61388
-well_log_toolkit-0.1.143.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-well_log_toolkit-0.1.143.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
-well_log_toolkit-0.1.143.dist-info/RECORD,,
+well_log_toolkit-0.1.145.dist-info/METADATA,sha256=5HaBS3lhnirT8Uu8SEvjFn60HRdG8Ft5sa-DUhl94yU,63473
+well_log_toolkit-0.1.145.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+well_log_toolkit-0.1.145.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
+well_log_toolkit-0.1.145.dist-info/RECORD,,