well-log-toolkit 0.1.143__tar.gz → 0.1.144__tar.gz

{well_log_toolkit-0.1.143 → well_log_toolkit-0.1.144}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.143
+Version: 0.1.144
 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 → well_log_toolkit-0.1.144}/README.md

@@ -250,6 +250,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 → well_log_toolkit-0.1.144}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "well-log-toolkit"
-version = "0.1.143"
+version = "0.1.144"
 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.143 → well_log_toolkit-0.1.144}/well_log_toolkit/property.py

@@ -1872,7 +1872,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 +1885,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 +1935,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 +1951,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 +1961,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 +1971,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 +2007,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 +2016,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 +2030,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
@@ -2049,12 +2084,13 @@ class Property(PropertyOperationsMixin):
                 '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
 

{well_log_toolkit-0.1.143 → well_log_toolkit-0.1.144}/well_log_toolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.143
+Version: 0.1.144
 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: