well-log-toolkit 0.1.142__py3-none-any.whl → 0.1.144__py3-none-any.whl

well_log_toolkit/property.py

@@ -1167,6 +1167,220 @@ class Property(PropertyOperationsMixin):
 
         return new_prop
 
+    def filter_intervals(
+        self,
+        intervals: Union[list[dict], dict[str, list[dict]], str],
+        name: str = "Custom_Intervals",
+        insert_boundaries: Optional[bool] = None,
+        save: Optional[str] = None
+    ) -> 'Property':
+        """
+        Filter by custom depth intervals defined as top/base pairs.
+
+        Each interval is processed independently, allowing overlapping intervals
+        where the same depths can be counted in multiple zones.
+
+        Parameters
+        ----------
+        intervals : list[dict] | dict[str, list[dict]] | str
+            Interval definitions. Can be:
+            - list[dict]: Direct list of intervals for the current well
+            - dict[str, list[dict]]: Well-specific intervals keyed by well name.
+              Current well must be included or raises error.
+            - str: Name of a previously saved filter to use
+        name : str, default "Custom_Intervals"
+            Name for the filter property (used in output labels)
+        insert_boundaries : bool, optional
+            If True, insert synthetic samples at interval boundaries.
+            Default is True for continuous properties, False for sampled properties.
+        save : str, optional
+            If provided, save the intervals to the well(s) under this name.
+            Overwrites any existing filter with the same name.
+
+        Returns
+        -------
+        Property
+            New property instance with custom intervals as filter dimension
+
+        Examples
+        --------
+        >>> # Filter by custom zones
+        >>> intervals = [
+        ...     {"name": "Zone_A", "top": 2500, "base": 2600},
+        ...     {"name": "Zone_B", "top": 2600, "base": 2750},
+        ... ]
+        >>> filtered = well.PHIE.filter_intervals(intervals)
+        >>> filtered.sums_avg()
+
+        >>> # Save intervals for reuse
+        >>> well.PHIE.filter_intervals(intervals, save="Reservoir_Zones")
+        >>> # Later, use saved filter by name
+        >>> well.PHIE.filter_intervals("Reservoir_Zones").sums_avg()
+
+        >>> # Save different intervals for multiple wells
+        >>> manager.well_A.PHIE.filter_intervals({
+        ...     "well_A": intervals_a,
+        ...     "well_B": intervals_b
+        ... }, save="My_Zones")
+        >>> # Now both wells have "My_Zones" saved
+
+        >>> # Overlapping intervals - each calculated independently
+        >>> intervals = [
+        ...     {"name": "Full_Reservoir", "top": 2500, "base": 2800},
+        ...     {"name": "Upper_Only", "top": 2500, "base": 2650}
+        ... ]
+        >>> # Depths 2500-2650 will be counted in BOTH zones
+
+        Notes
+        -----
+        Intervals can overlap or have gaps. Depths outside all intervals
+        are excluded from statistics. Overlapping intervals are calculated
+        independently - the same depths can contribute to multiple zones.
+        """
+        # Handle string input (saved filter name)
+        if isinstance(intervals, str):
+            filter_name = intervals
+            if self.parent_well is None:
+                raise PropertyNotFoundError(
+                    f"Cannot use saved filter '{filter_name}': no parent well reference."
+                )
+            if filter_name not in self.parent_well._saved_filter_intervals:
+                available = list(self.parent_well._saved_filter_intervals.keys())
+                raise PropertyNotFoundError(
+                    f"Saved filter '{filter_name}' not found in well '{self.parent_well.name}'. "
+                    f"Available filters: {available if available else 'none'}"
+                )
+            intervals = self.parent_well._saved_filter_intervals[filter_name]
+            # Use filter name as the output name if not overridden
+            if name == "Custom_Intervals":
+                name = filter_name
+
+        # Handle dict input (well-specific intervals)
+        elif isinstance(intervals, dict):
+            if self.parent_well is None:
+                raise PropertyNotFoundError(
+                    "Cannot use well-specific intervals: no parent well reference."
+                )
+
+            well_name = self.parent_well.name
+            sanitized_name = self.parent_well.sanitized_name
+
+            # Check if current well is in the dict (by name or sanitized name)
+            current_well_intervals = []  # Default to empty if not found
+            if well_name in intervals:
+                current_well_intervals = intervals[well_name]
+            elif sanitized_name in intervals:
+                current_well_intervals = intervals[sanitized_name]
+
+            # Save to all specified wells if save parameter provided
+            if save and self.parent_well.parent_manager:
+                manager = self.parent_well.parent_manager
+                for key, well_intervals in intervals.items():
+                    # Find well by name or sanitized name
+                    target_well = None
+                    for w in manager._wells.values():
+                        if w.name == key or w.sanitized_name == key:
+                            target_well = w
+                            break
+                    if target_well:
+                        self._validate_intervals(well_intervals)
+                        target_well._saved_filter_intervals[save] = well_intervals
+
+            intervals = current_well_intervals
+
+        # Validate and save if we have intervals
+        if intervals:
+            # Validate interval structure
+            self._validate_intervals(intervals)
+
+            # Save to current well if save parameter provided
+            if save and self.parent_well:
+                self.parent_well._saved_filter_intervals[save] = intervals
+
+        # Determine if we should insert boundaries
+        if insert_boundaries is None:
+            insert_boundaries = self.type != 'sampled'
+
+        # Collect all boundary depths from intervals for boundary insertion
+        if insert_boundaries and intervals:
+            boundary_depths = []
+            for interval in intervals:
+                boundary_depths.append(float(interval['top']))
+                boundary_depths.append(float(interval['base']))
+            boundary_depths = np.unique(boundary_depths)
+
+            # Create a temporary discrete property just for boundary insertion
+            # Values don't matter here, only the depths
+            temp_discrete = Property(
+                name=name,
+                depth=boundary_depths,
+                values=np.arange(len(boundary_depths), dtype=float),
+                parent_well=self.parent_well,
+                prop_type='discrete'
+            )
+            new_depth, new_values, new_secondaries = self._insert_boundary_samples(temp_discrete)
+        else:
+            new_depth = self.depth.copy()
+            new_values = self.values.copy()
+            new_secondaries = [sp for sp in self.secondary_properties]
+
+        # Create new Property instance
+        new_prop = Property(
+            name=self.name,
+            depth=new_depth,
+            values=new_values,
+            parent_well=self.parent_well,
+            unit=self.unit,
+            prop_type=self.type,
+            description=self.description,
+            null_value=-999.25,
+            labels=self.labels,
+            colors=self.colors,
+            styles=self.styles,
+            thicknesses=self.thicknesses,
+            source_las=self.source_las,
+            source_name=self.source_name,
+            original_name=self.original_name
+        )
+        new_prop.secondary_properties = new_secondaries
+
+        # Store custom intervals for independent processing in sums_avg/discrete_summary
+        new_prop._custom_intervals = intervals
+        new_prop._custom_intervals_name = name
+
+        # Track filtering metadata
+        new_prop._is_filtered = True
+        new_prop._original_sample_count = len(self.depth)
+        new_prop._boundary_samples_inserted = len(new_depth) - len(self.depth)
+
+        return new_prop
+
+    def _validate_intervals(self, intervals: list[dict]) -> None:
+        """
+        Validate interval structure.
+
+        Parameters
+        ----------
+        intervals : list[dict]
+            List of interval definitions to validate
+
+        Raises
+        ------
+        ValueError
+            If any interval is invalid
+        """
+        for i, interval in enumerate(intervals):
+            if not isinstance(interval, dict):
+                raise ValueError(f"Interval {i} must be a dict, got {type(interval)}")
+            for key in ('name', 'top', 'base'):
+                if key not in interval:
+                    raise ValueError(f"Interval {i} missing required key '{key}'")
+            if interval['top'] >= interval['base']:
+                raise ValueError(
+                    f"Interval '{interval['name']}': top ({interval['top']}) must be "
+                    f"less than base ({interval['base']})"
+                )
+
     def _insert_boundary_samples(
         self,
         discrete_prop: 'Property'
@@ -1500,6 +1714,16 @@ class Property(PropertyOperationsMixin):
         valid_mask = ~np.isnan(self.values)
         gross_thickness = float(np.sum(full_intervals[valid_mask]))
 
+        # 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_stats_by_intervals(
+                weighted=weighted,
+                arithmetic=arithmetic,
+                gross_thickness=gross_thickness,
+                precision=precision
+            )
+
         if not self.secondary_properties:
             # No filters, simple statistics
             return self._compute_stats(
@@ -1520,6 +1744,51 @@ class Property(PropertyOperationsMixin):
             precision=precision
         )
 
+    def _compute_stats_by_intervals(
+        self,
+        weighted: bool,
+        arithmetic: bool,
+        gross_thickness: float,
+        precision: int
+    ) -> dict:
+        """
+        Compute statistics for each custom interval independently.
+
+        This allows overlapping intervals where the same depths can
+        contribute to multiple zones.
+        """
+        result = {}
+
+        for interval in self._custom_intervals:
+            interval_name = interval['name']
+            top = float(interval['top'])
+            base = float(interval['base'])
+
+            # Create mask for this interval (top <= depth < base)
+            interval_mask = (self.depth >= top) & (self.depth < base)
+
+            # If there are secondary properties, group within this interval
+            if self.secondary_properties:
+                result[interval_name] = self._recursive_group(
+                    0,
+                    interval_mask,
+                    weighted=weighted,
+                    arithmetic=arithmetic,
+                    gross_thickness=gross_thickness,
+                    precision=precision
+                )
+            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
+                )
+
+        return result
+
     def discrete_summary(self, precision: int = 6) -> dict:
         """
         Compute summary statistics for discrete/categorical properties.
@@ -1570,6 +1839,14 @@ class Property(PropertyOperationsMixin):
         valid_mask = ~np.isnan(self.values)
         gross_thickness = float(np.sum(full_intervals[valid_mask]))
 
+        # 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(
+                gross_thickness=gross_thickness,
+                precision=precision
+            )
+
         if not self.secondary_properties:
             # No filters, compute stats for all discrete values
             return self._compute_discrete_stats(
@@ -1586,12 +1863,80 @@ class Property(PropertyOperationsMixin):
             precision=precision
         )
 
+    def _compute_discrete_stats_by_intervals(
+        self,
+        gross_thickness: float,
+        precision: int
+    ) -> dict:
+        """
+        Compute discrete statistics for each custom interval independently.
+
+        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.
+        """
+        result = {}
+
+        for interval in self._custom_intervals:
+            interval_name = interval['name']
+            top = float(interval['top'])
+            base = float(interval['base'])
+
+            # 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:
+                facies_stats = self._recursive_discrete_group(
+                    0,
+                    interval_mask,
+                    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
+                facies_stats = self._compute_discrete_stats(
+                    interval_mask,
+                    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(
         self,
         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.
@@ -1606,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
         -------
@@ -1614,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]
@@ -1624,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
@@ -1660,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
@@ -1669,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.
@@ -1682,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
@@ -1733,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/well.py

@@ -220,6 +220,8 @@ class Well:
         self._deleted_sources: list[str] = []  # List of source names to delete
         # Track sources marked for rename (to rename files on save)
         self._renamed_sources: dict[str, str] = {}  # {old_name: new_name}
+        # Saved filter intervals for use with filter_intervals()
+        self._saved_filter_intervals: dict[str, list[dict]] = {}  # {filter_name: [intervals]}
 
     def __setattr__(self, name: str, value):
         """
@@ -1226,7 +1228,58 @@ class Well:
             f"Property '{name}' not found in well '{self.name}'. "
             f"Available properties: {available or 'none'}"
         )
-    
+
+    def get_intervals(self, name: str) -> list[dict]:
+        """
+        Get saved filter intervals by name.
+
+        Parameters
+        ----------
+        name : str
+            Name of the saved filter intervals
+
+        Returns
+        -------
+        list[dict]
+            List of interval definitions, each with keys 'name', 'top', 'base'
+
+        Raises
+        ------
+        KeyError
+            If no intervals with this name exist
+
+        Examples
+        --------
+        >>> # Save intervals
+        >>> well.PHIE.filter_intervals([
+        ...     {"name": "Zone_A", "top": 2500, "base": 2650}
+        ... ], save="My_Zones")
+        >>>
+        >>> # Retrieve them later
+        >>> intervals = well.get_intervals("My_Zones")
+        >>> print(intervals)
+        [{'name': 'Zone_A', 'top': 2500, 'base': 2650}]
+        """
+        if name not in self._saved_filter_intervals:
+            available = list(self._saved_filter_intervals.keys())
+            raise KeyError(
+                f"Filter intervals '{name}' not found in well '{self.name}'. "
+                f"Available: {available if available else 'none'}"
+            )
+        return self._saved_filter_intervals[name]
+
+    @property
+    def saved_intervals(self) -> list[str]:
+        """
+        List of saved filter interval names.
+
+        Returns
+        -------
+        list[str]
+            Names of all saved filter intervals
+        """
+        return list(self._saved_filter_intervals.keys())
+
     @staticmethod
     def _is_regular_grid(depth: np.ndarray, tolerance: float = 1e-6) -> tuple[bool, Optional[float]]:
         """

{well_log_toolkit-0.1.142.dist-info → well_log_toolkit-0.1.144.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: well-log-toolkit
-Version: 0.1.142
+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.142.dist-info → well_log_toolkit-0.1.144.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=sMA4sfcI_qXg4L9rdL19gmkzPEyPa_3X7LAFdJNZ6Jk,85224
+well_log_toolkit/property.py,sha256=4g5-_WRdJ9HwDKkufU4s_oOnCh6Deg58ZX5jE9Uwx2c,99833
 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=Aav5Y-rui8YsJdvk7BFndNPUu1O9mcjwDApAGyqV9kw,104535
-well_log_toolkit-0.1.142.dist-info/METADATA,sha256=6Lvy02zTkolrANhxaWVTUY0l5HHqhbmRjlOyebp9fC4,61388
-well_log_toolkit-0.1.142.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-well_log_toolkit-0.1.142.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
-well_log_toolkit-0.1.142.dist-info/RECORD,,
+well_log_toolkit/well.py,sha256=n6XfaGSjGtyXCIaAr0ytslIK0DMUY_fSPQ_VCqj8jaU,106173
+well_log_toolkit-0.1.144.dist-info/METADATA,sha256=5GdblMrgAGxLNG0LA9pKav9UHUl4iTps6Zl34xK-4CA,63473
+well_log_toolkit-0.1.144.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+well_log_toolkit-0.1.144.dist-info/top_level.txt,sha256=BMOo7OKLcZEnjo0wOLMclwzwTbYKYh31I8RGDOGSBdE,17
+well_log_toolkit-0.1.144.dist-info/RECORD,,