integrate_module 0.99.2__tar.gz → 0.99.5__tar.gz

{integrate_module-0.99.2/integrate_module.egg-info → integrate_module-0.99.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: integrate_module
-Version: 0.99.2
+Version: 0.99.5
 Summary: Localized probabilistic data integration
 Author-email: Thomas Mejer Hansen <tmeha@geo.au.dk>
 License: MIT

{integrate_module-0.99.2 → integrate_module-0.99.5}/integrate/__init__.py

@@ -36,6 +36,7 @@ from integrate.integrate import posterior_cumulative_thickness
 from integrate.integrate import use_parallel
 from integrate.integrate import kl_divergence
 from integrate.integrate import entropy
+from integrate.integrate import discrete_data_entropy
 from integrate.integrate import class_id_to_idx
 from integrate.integrate import is_notebook
 from integrate.integrate import get_hypothesis_probability
@@ -94,6 +95,7 @@ from integrate.integrate_plot import plot_profile_discrete
 from integrate.integrate_plot import plot_cumulative_probability_profile
 from integrate.integrate_plot import plot_T_EV
 from integrate.integrate_plot import plot_data_xy
+from integrate.integrate_plot import plot_discrete_data_entropy
 from integrate.integrate_plot import plot_data
 from integrate.integrate_plot import plot_data_prior_post
 from integrate.integrate_plot import plot_data_prior

{integrate_module-0.99.2 → integrate_module-0.99.5}/integrate/integrate.py

@@ -2963,12 +2963,95 @@ def entropy(P, base = None):
     >>> entropy(P)
     array([1.0, 0.469])
     """
-    P = np.atleast_2d(P)    
+    P = np.atleast_2d(P)
     if base is None:
         base = P.shape[1]
     H = -np.sum(P*np.log(P)/np.log(base), axis=1)
     return H
 
+
+def discrete_data_entropy(f_data_h5, id_list, depth_reduce='min', showInfo=1):
+    """
+    Compute the pointwise (per survey location) entropy of one or more
+    multinomial discrete /D{id} data entries in a DATA HDF5 file.
+
+    Each location's discrete observation is a probability-over-classes
+    profile spanning ``nm`` depth layers (shape ``(ns, nclass, nm)`` per id,
+    as written by :func:`save_data_multinomial`, e.g. via
+    :func:`save_borehole_data`). Entropy is computed per (location,
+    depth-layer) using ``scipy.stats.entropy`` (which correctly handles
+    exact-zero probabilities, unlike :func:`entropy`), the depth axis is
+    then collapsed per ``depth_reduce``, and — if more than one id is given —
+    the pointwise minimum across ids is returned (i.e. the best-informed id
+    at each location; adding more ids can only lower or keep equal the
+    entropy at a given location, never raise it).
+
+    Parameters
+    ----------
+    f_data_h5 : str
+        Path to the DATA HDF5 file.
+    id_list : int or list of int
+        One or more dataset ids referencing multinomial /D{id} groups
+        (e.g. from ``save_borehole_data()``'s ``id_out`` / ``id_borehole_list``).
+    depth_reduce : {'min', 'mean'}, optional
+        How to collapse the per-location depth-layer axis, per id, before
+        combining across ids. ``'min'`` (default) takes the lowest (most
+        informative) entropy value across depth layers, i.e. each id's best
+        depth-layer represents it at that location; ``'mean'`` averages
+        entropy across depth layers instead.
+    showInfo : int, optional
+        Verbosity level passed through to :func:`load_data`. Default 1.
+
+    Returns
+    -------
+    H : ndarray, shape (ns,)
+        Pointwise entropy in [0, 1] (base = nclass). NaN at locations not
+        covered by any of the given ids (``i_use == 0`` for all of them).
+
+    Examples
+    --------
+    >>> H = ig.discrete_data_entropy(f_data_h5, id_borehole_list)
+    >>> H = ig.discrete_data_entropy(f_data_h5, id_borehole_list, depth_reduce='mean')
+    """
+    import scipy as sp
+    import warnings
+    import integrate as ig
+
+    if not isinstance(id_list, list):
+        id_list = [id_list]
+    if depth_reduce not in ('mean', 'min'):
+        raise ValueError("depth_reduce must be 'mean' or 'min'")
+
+    DATA = ig.load_data(f_data_h5, id_arr=id_list, showInfo=showInfo)
+
+    H_per_id = []
+    for i, id in enumerate(id_list):
+        if DATA['noise_model'][i] != 'multinomial':
+            raise ValueError(
+                "D%d is not a multinomial dataset (noise_model=%r)" %
+                (id, DATA['noise_model'][i]))
+        P = DATA['d_obs'][i]                     # (ns, nclass, nm)
+        i_use = np.asarray(DATA['i_use'][i]).ravel().astype(bool)
+        ns, nclass, nm = P.shape
+
+        H = np.full((ns, nm), np.nan)
+        if np.any(i_use):
+            H[i_use, :] = sp.stats.entropy(
+                P[i_use].transpose(1, 0, 2).reshape(nclass, -1),
+                base=nclass
+            ).reshape(-1, nm)
+
+        with warnings.catch_warnings():
+            warnings.simplefilter('ignore', category=RuntimeWarning)
+            H_id = np.nanmean(H, axis=1) if depth_reduce == 'mean' else np.nanmin(H, axis=1)
+        H_per_id.append(H_id)
+
+    with warnings.catch_warnings():
+        warnings.simplefilter('ignore', category=RuntimeWarning)
+        H_map = np.nanmin(np.vstack(H_per_id), axis=0)
+    return H_map
+
+
 def class_id_to_idx(D, class_id=None):
     """
     Convert class identifiers to indices.

{integrate_module-0.99.2 → integrate_module-0.99.5}/integrate/integrate_borehole.py

@@ -572,8 +572,8 @@ def rescale_P_obs_temperature(P_obs, T=1.0):
 
     return P_obs_scaled
 
-def Pobs_to_datagrid(P_obs, X, Y, f_data_h5, r_data=10, r_dis=100, doPlot=False,
-                     nan_freq=0.8, r_data_i_use=None):
+def Pobs_to_datagrid(P_obs, X, Y, f_data_h5, range_data=10, range_xyz=100, doPlot=False,
+                     range_data_nan_freq=0.8, range_data_i_use=None):
     """
     Convert point-based discrete probability observations to gridded data with distance-based weighting.
 
@@ -594,23 +594,23 @@ def Pobs_to_datagrid(P_obs, X, Y, f_data_h5, r_data=10, r_dis=100, doPlot=False,
         Y coordinate (e.g., UTM Northing) of the observation point.
     f_data_h5 : str
         Path to HDF5 data file containing survey geometry (X, Y coordinates).
-    r_data : float, optional
+    range_data : float, optional
         Inner radius in meters within which observations have full strength.
         Default is 10 meters.
-    r_dis : float, optional
+    range_xyz : float, optional
         Outer radius in meters for distance-based weighting. Beyond this distance,
         observations are fully attenuated (temperature → ∞). Default is 100 meters.
     doPlot : bool, optional
         If True, creates diagnostic plots showing weight distributions.
         Default is False.
-    nan_freq : float, optional
+    range_data_nan_freq : float, optional
         NaN-frequency threshold for automatic data-gate selection inside
         :func:`get_weight_from_position`. Gates where the fraction of
         non-NaN values is below this threshold are excluded. Default 0.8.
-        Ignored when ``r_data_i_use`` is provided.
-    r_data_i_use : array-like of int or None, optional
+        Ignored when ``range_data_i_use`` is provided.
+    range_data_i_use : array-like of int or None, optional
         Explicit gate/channel indices to use for data-distance computation
-        inside :func:`get_weight_from_position`. Overrides ``nan_freq`` when
+        inside :func:`get_weight_from_position`. Overrides ``range_data_nan_freq`` when
         provided. Default None.
 
     Returns
@@ -649,7 +649,7 @@ def Pobs_to_datagrid(P_obs, X, Y, f_data_h5, r_data=10, r_dis=100, doPlot=False,
     >>> P_obs = compute_P_obs_discrete(depth_top, depth_bottom, lithology, z, class_id)
     >>> X_well, Y_well = 543000.0, 6175800.0
     >>> d_obs, i_use, T_all = Pobs_to_datagrid(P_obs, X_well, Y_well, 'survey_data.h5',
-    ...                                  r_data=10, r_dis=100)
+    ...                                  range_data=10, range_xyz=100)
     >>> # Write to data file
     >>> ig.save_data_multinomial(d_obs, i_use=i_use, id=2, f_data_h5='survey_data.h5')
 
@@ -673,8 +673,8 @@ def Pobs_to_datagrid(P_obs, X, Y, f_data_h5, r_data=10, r_dis=100, doPlot=False,
 
     # Compute distance-based weights for all grid points
     w_combined, w_dis, w_data, i_use_from_func = ig.get_weight_from_position(
-        f_data_h5, X, Y, r_data=r_data, r_dis=r_dis, doPlot=doPlot,
-        nan_freq=nan_freq, r_data_i_use=r_data_i_use
+        f_data_h5, X, Y, range_data=range_data, range_xyz=range_xyz, doPlot=doPlot,
+        range_data_nan_freq=range_data_nan_freq, range_data_i_use=range_data_i_use
     )
 
     # Convert distance weight to temperature
@@ -703,9 +703,9 @@ def Pobs_to_datagrid(P_obs, X, Y, f_data_h5, r_data=10, r_dis=100, doPlot=False,
 
 
 
-def get_weight_from_position(f_data_h5, x_well=0, y_well=0, i_ref=-1, r_dis=400, r_data=2,
+def get_weight_from_position(f_data_h5, x_well=0, y_well=0, i_ref=-1, range_xyz=400, range_data=2,
                              useLog=True, doPlot=False, plFile=None, showInfo=0,
-                             nan_freq=0.8, r_data_i_use=None):
+                             range_data_nan_freq=0.8, range_data_i_use=None):
     """Calculate weights based on distance and data similarity to a reference point.
 
     This function computes three sets of weights:
@@ -723,9 +723,9 @@ def get_weight_from_position(f_data_h5, x_well=0, y_well=0, i_ref=-1, r_dis=400,
         Y coordinate of reference point (well). Default 0.
     i_ref : int, optional
         Index of reference point. Default -1 (auto-calculated as closest to x_well, y_well).
-    r_dis : float, optional
+    range_xyz : float, optional
         Geographic XY distance range [m] for spatial weighting. Default 400.
-    r_data : float, optional
+    range_data : float, optional
         Data-space similarity range parameter for data weighting. Default 2.
     useLog : bool, optional
         Apply log10 transform to data before computing similarity. Default True.
@@ -735,16 +735,16 @@ def get_weight_from_position(f_data_h5, x_well=0, y_well=0, i_ref=-1, r_dis=400,
         Output filename for the diagnostic plot. Auto-generated if None.
     showInfo : int, optional
         Verbosity level. Default 0.
-    nan_freq : float, optional
+    range_data_nan_freq : float, optional
         NaN-frequency threshold for automatic gate selection. Gates where the
         fraction of non-NaN values across all soundings is below this threshold
         are excluded from the data-distance computation. Default 0.8.
-        Ignored when ``r_data_i_use`` is provided.
-    r_data_i_use : array-like of int or None, optional
+        Ignored when ``range_data_i_use`` is provided.
+    range_data_i_use : array-like of int or None, optional
         Explicit gate/channel indices to use for the data-distance computation.
-        When provided, overrides the ``nan_freq`` automatic selection.
+        When provided, overrides the ``range_data_nan_freq`` automatic selection.
         A NaN check at the reference sounding is still applied.
-        Default None (use ``nan_freq`` threshold).
+        Default None (use ``range_data_nan_freq`` threshold).
 
     Returns
     -------
@@ -760,8 +760,8 @@ def get_weight_from_position(f_data_h5, x_well=0, y_well=0, i_ref=-1, r_dis=400,
     Notes
     -----
     Weights are calculated using Gaussian functions:
-    - Distance weights: exp(-dis² / r_dis²)
-    - Data weights:     exp(-sum_dd² / r_data²)
+    - Distance weights: exp(-dis² / range_xyz²)
+    - Data weights:     exp(-sum_dd² / range_data²)
     where dis is geographic distance and sum_dd is cumulative data difference.
     """
     import integrate as ig
@@ -777,12 +777,12 @@ def get_weight_from_position(f_data_h5, x_well=0, y_well=0, i_ref=-1, r_dis=400,
         i_ref = np.argmin((X-x_well)**2 + (Y-y_well)**2)
 
     # Select gates to use for data-distance computation
-    if r_data_i_use is not None:
-        gates = np.asarray(r_data_i_use, dtype=int)
+    if range_data_i_use is not None:
+        gates = np.asarray(range_data_i_use, dtype=int)
     else:
         n_not_nan = np.sum(~np.isnan(d_obs), axis=0)
         n_not_nan_freq = n_not_nan / d_obs.shape[0]
-        gates = np.where(n_not_nan_freq > nan_freq)[0]
+        gates = np.where(n_not_nan_freq > range_data_nan_freq)[0]
     # Remove gates that are NaN at the reference sounding
     gates = gates[~np.isnan(d_obs[i_ref, gates])]
     i_use = gates
@@ -795,12 +795,12 @@ def get_weight_from_position(f_data_h5, x_well=0, y_well=0, i_ref=-1, r_dis=400,
         d_test =d_obs[:,i_use]
     dd = np.abs(d_test - d_ref)
     sum_dd = np.sum(dd, axis=1)
-    w_data = np.exp(-1*sum_dd**2/r_data**2)
-    
+    w_data = np.exp(-1*sum_dd**2/range_data**2)
+
 
     # Compute the distance from each data point to the actual borehole location
     dis = np.sqrt((X-x_well)**2 + (Y-y_well)**2)
-    w_dis = np.exp(-1*dis**2/r_dis**2)
+    w_dis = np.exp(-1*dis**2/range_xyz**2)
 
     w_combined = w_data * w_dis
 
@@ -838,7 +838,7 @@ def get_weight_from_position(f_data_h5, x_well=0, y_well=0, i_ref=-1, r_dis=400,
         plt.xlabel('X')
         plt.ylabel('Y')
         if plFile is None:
-            plFile = 'weights_%d_%d_%d_rdis%d_rdata%d.png' % (x_well,y_well,i_ref,r_dis,r_data)
+            plFile = 'weights_%d_%d_%d_rdis%d_rdata%d.png' % (x_well,y_well,i_ref,range_xyz,range_data)
         plt.savefig(plFile, dpi=300)
 
     return w_combined, w_dis, w_data, i_ref
@@ -1023,46 +1023,54 @@ def save_borehole_data(f_prior_h5, f_data_h5, BH, **kwargs):
         Path to the prior HDF5 file.
     f_data_h5 : str
         Path to the observed-data HDF5 file.
-    BH : dict
+    BH : dict or list of dict
         Borehole dictionary with keys depth_top, depth_bottom, class_obs,
         class_prob, X, Y, name, method. Two optional keys control the
-        distance-weighting radii when r_data / r_dis are not passed as
-        explicit kwargs:
+        distance-weighting radii when range_data / range_xyz are not passed
+        as explicit kwargs:
 
         * ``range_data`` (float, optional) — data-space similarity radius.
           Survey points whose EM data response is similar to the borehole
           location receive higher weight; points that are more dissimilar are
-          down-weighted. Default: 1,000,000 (effectively no cutoff).
-        * ``range_dis`` (float, optional) — geographic XY distance [m] beyond
+          down-weighted. Only used if present and non-negative; otherwise the
+          default applies. Default: 1,000,000 (effectively no cutoff).
+        * ``range_xyz`` (float, optional) — geographic XY distance [m] beyond
           which the borehole exerts no influence on nearby survey points.
-          Default: 300 m.
-        * ``nan_freq`` (float, optional) — NaN-frequency threshold for automatic
+          Only used if present and non-negative; otherwise the default
+          applies. Default: 300 m.
+        * ``range_data_nan_freq`` (float, optional) — NaN-frequency threshold for automatic
           data-gate selection. Default: 0.8.
-        * ``r_data_i_use`` (list of int, optional) — explicit gate indices for
-          data-distance computation; overrides ``nan_freq`` when provided.
+        * ``range_data_i_use`` (list of int, optional) — explicit gate indices for
+          data-distance computation; overrides ``range_data_nan_freq`` when provided.
+
+        If ``BH`` is a list of dicts, each borehole is processed in turn
+        (one call per element, in order) using the same ``**kwargs`` for
+        every borehole; a per-borehole ``range_data``/``range_xyz``/etc. key
+        set inside an individual dict still takes effect for that borehole
+        exactly as in the single-dict case. See ``Returns`` below.
     **kwargs
         im_prior : int, optional
             Index of the discrete model parameter in f_prior_h5 (e.g. 2 for /M2).
             Default is 2.
         parallel : bool, optional
             Enable parallel mode computation. Default is False.
-        r_data : float, optional
+        range_data : float, optional
             Data-space similarity radius. Overrides ``BH['range_data']`` when
-            provided. Resolution order: explicit kwarg > BH['range_data'] >
-            1,000,000 (no cutoff).
-        r_dis : float, optional
-            Geographic XY fade-out distance [m]. Overrides ``BH['range_dis']``
-            when provided. Resolution order: explicit kwarg > BH['range_dis'] >
-            300 m.
-        nan_freq : float, optional
+            provided. Resolution order: explicit kwarg > BH['range_data']
+            (if present and non-negative) > 1,000,000 (no cutoff).
+        range_xyz : float, optional
+            Geographic XY fade-out distance [m]. Overrides ``BH['range_xyz']``
+            when provided. Resolution order: explicit kwarg > BH['range_xyz']
+            (if present and non-negative) > 300 m.
+        range_data_nan_freq : float, optional
             NaN-frequency threshold for automatic data-gate selection. Gates
             where the fraction of non-NaN soundings is below this threshold are
             excluded from data-distance computation. Resolution order: explicit
-            kwarg > BH['nan_freq'] > 0.8. Ignored when ``r_data_i_use`` is set.
-        r_data_i_use : list of int or None, optional
+            kwarg > BH['range_data_nan_freq'] > 0.8. Ignored when ``range_data_i_use`` is set.
+        range_data_i_use : list of int or None, optional
             Explicit gate/channel indices to use for data-distance computation.
-            Overrides ``nan_freq`` when provided. Resolution order: explicit
-            kwarg > BH['r_data_i_use'] > None.
+            Overrides ``range_data_nan_freq`` when provided. Resolution order: explicit
+            kwarg > BH['range_data_i_use'] > None.
         doPlot : bool, optional
             Plot distance-weight maps. Default is False.
         showInfo : int, optional
@@ -1072,32 +1080,56 @@ def save_borehole_data(f_prior_h5, f_data_h5, BH, **kwargs):
     Returns
     -------
     id_prior : int
-        Dataset index of the new /D entry added to f_prior_h5.
+        If ``BH`` is a single dict: dataset index of the new /D entry added
+        to f_prior_h5.
     id_out : int
-        Dataset index of the new /D entry added to f_data_h5.
+        If ``BH`` is a single dict: dataset index of the new /D entry added
+        to f_data_h5.
+    id_prior_list : list of int
+        If ``BH`` is a list of dicts: dataset indices of the new /D entries
+        added to f_prior_h5, one per borehole, same order as ``BH``.
+    id_borehole_list : list of int
+        If ``BH`` is a list of dicts: dataset indices of the new /D entries
+        added to f_data_h5, one per borehole, same order as ``BH``.
 
     Examples
     --------
     >>> # Single borehole
     >>> id_prior, id_data = ig.save_borehole_data(f_prior_h5, f_data_h5, BH)
 
-    >>> # All boreholes — collect data IDs for joint inversion
-    >>> id_borehole_list = []
-    >>> for BH in BHOLES:
-    ...     _, id_out = ig.save_borehole_data(f_prior_h5, f_data_h5, BH,
-    ...                                       r_data=2, r_dis=300, parallel=True)
-    ...     id_borehole_list.append(id_out)
+    >>> # All boreholes in one call — collect data IDs for joint inversion
+    >>> id_prior_list, id_borehole_list = ig.save_borehole_data(
+    ...     f_prior_h5, f_data_h5, BHOLES,
+    ...     range_data=2, range_xyz=300, parallel=True)
     >>> f_post_h5 = ig.integrate_rejection(f_prior_h5, f_data_h5,
     ...                                    id_use=[1] + id_borehole_list)
     """
+    if isinstance(BH, list):
+        id_prior_list = []
+        id_borehole_list = []
+        for bh in BH:
+            id_prior, id_out = save_borehole_data(f_prior_h5, f_data_h5, bh, **kwargs)
+            id_prior_list.append(id_prior)
+            id_borehole_list.append(id_out)
+        return id_prior_list, id_borehole_list
+
     import integrate as ig
 
+    def _resolve_radius(name, default):
+        val = kwargs.get(name, None)
+        if val is not None:
+            return val
+        val = BH.get(name, None)
+        if val is not None and val >= 0:
+            return val
+        return default
+
     im_prior = kwargs.get('im_prior', 2)
     parallel = kwargs.get('parallel', False)
-    r_data       = kwargs.get('r_data',       BH.get('range_data',   1_000_000))
-    r_dis        = kwargs.get('r_dis',        BH.get('range_dis',    300))
-    nan_freq     = kwargs.get('nan_freq',     BH.get('nan_freq',     0.8))
-    r_data_i_use = kwargs.get('r_data_i_use', BH.get('r_data_i_use', None))
+    range_data   = _resolve_radius('range_data', 1_000_000)
+    range_xyz    = _resolve_radius('range_xyz',  300)
+    range_data_nan_freq     = kwargs.get('range_data_nan_freq',     BH.get('range_data_nan_freq',     0.8))
+    range_data_i_use = kwargs.get('range_data_i_use', BH.get('range_data_i_use', None))
     doPlot   = kwargs.get('doPlot', False)
     showInfo = kwargs.get('showInfo', 1)
 
@@ -1109,8 +1141,8 @@ def save_borehole_data(f_prior_h5, f_data_h5, BH, **kwargs):
     # Step 2: extrapolate point observations to the survey grid
     d_obs, i_use, T_use = Pobs_to_datagrid(
         P_obs, BH['X'], BH['Y'], f_data_h5,
-        r_data=r_data, r_dis=r_dis, doPlot=doPlot,
-        nan_freq=nan_freq, r_data_i_use=r_data_i_use)
+        range_data=range_data, range_xyz=range_xyz, doPlot=doPlot,
+        range_data_nan_freq=range_data_nan_freq, range_data_i_use=range_data_i_use)
 
     # Step 3: save gridded observations to f_data_h5
     id_out, _ = ig.save_data_multinomial(

{integrate_module-0.99.2 → integrate_module-0.99.5}/integrate/integrate_io.py

@@ -2967,6 +2967,10 @@ def get_case_data(case='DAUGAARD', loadAll=False, loadType='', filelist=None, **
         print("filelist to download:")
         print(filelist)
 
+    # Direct-download endpoint for the shared data. Use ERDA's 'share_redirect'
+    # form (serves raw file bytes, returns proper 404s), NOT the 'sharelink'
+    # browse link, which returns an HTML directory page with status 200 for any
+    # path and would be saved as a corrupt file.
     urlErda = 'https://anon.erda.au.dk/share_redirect/dxOLKDtoul'
     urlErdaCase = '%s/%s' % (urlErda,case)
     from tqdm import tqdm
@@ -2976,7 +2980,22 @@ def get_case_data(case='DAUGAARD', loadAll=False, loadType='', filelist=None, **
     if showInfo>-1:
         print('--> Got data for case: %s' % case)
 
-    return [f.replace('\\', '/').split('/')[-1] for f in filelist]
+    # Return the local filename for each requested file, but only if it was
+    # actually obtained (downloaded or already present locally). download_file
+    # saves to download_dir='.' using the basename, so we check for that here.
+    # Files that could not be obtained (e.g. missing on the remote server)
+    # return an empty string, so callers can test `if len(name) == 0`.
+    result = []
+    for f in filelist:
+        basename = f.replace('\\', '/').split('/')[-1]
+        if os.path.exists(basename):
+            result.append(basename)
+        else:
+            if showInfo>-1:
+                print('File %s was not obtained (missing locally and on remote); returning empty string.' % basename)
+            result.append('')
+
+    return result
 
 
 
@@ -5179,15 +5198,17 @@ def write_borehole(W, filename, **kwargs):
           Used only by :func:`plot_boreholes` to place the well on a shared
           elevation axis.  Has no effect on inversion.
         * ``range_data`` (float, optional) – data-space similarity radius used by
-          :func:`save_borehole_data` when ``r_data`` is not passed explicitly.
+          :func:`save_borehole_data` when ``range_data`` is not passed explicitly.
+          Only used if present and non-negative, otherwise the default applies.
           Default: 1,000,000 (no cutoff).
-        * ``range_dis`` (float, optional) – geographic XY fade-out distance [m]
-          used by :func:`save_borehole_data` when ``r_dis`` is not passed explicitly.
-          Default: 300 m.
-        * ``nan_freq`` (float, optional) – NaN-frequency threshold for automatic
+        * ``range_xyz`` (float, optional) – geographic XY fade-out distance [m]
+          used by :func:`save_borehole_data` when ``range_xyz`` is not passed
+          explicitly. Only used if present and non-negative, otherwise the
+          default applies. Default: 300 m.
+        * ``range_data_nan_freq`` (float, optional) – NaN-frequency threshold for automatic
           data-gate selection in :func:`save_borehole_data`. Default: 0.8.
-        * ``r_data_i_use`` (list of int, optional) – explicit gate/channel indices
-          for data-distance computation; overrides ``nan_freq`` when provided.
+        * ``range_data_i_use`` (list of int, optional) – explicit gate/channel indices
+          for data-distance computation; overrides ``range_data_nan_freq`` when provided.
 
         numpy arrays and scalars are automatically converted to plain
         Python lists/numbers so the file is human-readable JSON.

{integrate_module-0.99.2 → integrate_module-0.99.5}/integrate/integrate_plot.py

@@ -134,6 +134,8 @@ def get_colormap_and_limits(cmap_type='default', custom_clim=None):
         - 'default': Red-white-blue-black colormap for general use
         - 'resistivity': Log-scale colormap optimized for resistivity data
         - 'entropy': Grayscale colormap for uncertainty visualization
+        - 'discrete_data_entropy': Black-red-white colormap where 0 (informative)
+          is black and 1 (uninformative) is white
         - 'discrete': Categorical colormap for discrete classifications
         - 'temperature': Hot colormap for temperature/evidence fields
         - 'elevation': Terrain-like colormap for topographic data
@@ -201,6 +203,13 @@ def get_colormap_and_limits(cmap_type='default', custom_clim=None):
         cmap = LinearSegmentedColormap.from_list('entropy', colors, N=256)
         clim = [0, 1]
 
+    elif cmap_type == 'discrete_data_entropy':
+        # Black-red-white colormap: 0 (informative, low entropy) -> black,
+        # 1 (uninformative, high entropy) -> white
+        colors = ['black', 'red', 'white']
+        cmap = LinearSegmentedColormap.from_list('discrete_data_entropy', colors, N=256)
+        clim = [0, 1]
+
     elif cmap_type == 'discrete':
         # Categorical colormap for discrete classifications
         cmap = plt.cm.Set1
@@ -2844,6 +2853,55 @@ def plot_data_xy(f_data_h5, Dkey='D1', data_key='d_obs', data_channel=0, uselog=
 
     return fig
 
+
+def plot_discrete_data_entropy(f_data_h5, id_list, depth_reduce='min', **kwargs):
+    """
+    Plot the pointwise entropy of one or more multinomial discrete data
+    entries in a DATA HDF5 file, as a 2D map via :func:`plot_xy`.
+
+    See :func:`discrete_data_entropy` for how the entropy value at each
+    location is computed. Useful for visualizing, on a map, where one or
+    more discrete-type observations (e.g. borehole-derived data written by
+    :func:`save_borehole_data`) constrain the inversion versus where they
+    don't — low entropy marks confident/informative locations, high entropy
+    marks uninformative ones.
+
+    Parameters
+    ----------
+    f_data_h5 : str
+        Path to the DATA HDF5 file.
+    id_list : int or list of int
+        One or more dataset ids referencing multinomial /D{id} groups
+        (e.g. from ``save_borehole_data()``'s ``id_out`` / ``id_borehole_list``).
+    depth_reduce : {'min', 'mean'}, optional
+        See :func:`discrete_data_entropy`. Default ``'min'``.
+    **kwargs
+        Forwarded to :func:`plot_xy` (e.g. cmap, clim, hardcopy, title, ax, ...).
+
+    Returns
+    -------
+    fig, ax, sc
+        As returned by :func:`plot_xy`.
+
+    Examples
+    --------
+    >>> fig, ax, sc = ig.plot_discrete_data_entropy(f_data_h5, id_borehole_list)
+    """
+    import integrate as ig
+
+    H = ig.discrete_data_entropy(f_data_h5, id_list, depth_reduce=depth_reduce,
+                                  showInfo=kwargs.pop('showInfo', 1))
+
+    ids_str = ','.join(str(i) for i in (id_list if isinstance(id_list, list) else [id_list]))
+    kwargs.setdefault('title', 'Minimum discrete data entropy (D%s)' % ids_str)
+    kwargs.setdefault('colorbar_label', 'Entropy')
+    _cmap, _clim = get_colormap_and_limits('discrete_data_entropy')
+    kwargs.setdefault('cmap', _cmap)
+    kwargs.setdefault('clim', _clim)
+
+    return plot_xy(H, f_data_h5=f_data_h5, **kwargs)
+
+
 def plot_data(f_data_h5, i_plot=[], Dkey=[], plType='imshow', uselog=True, **kwargs):
     """
     Plot observational data from an HDF5 file.

{integrate_module-0.99.2 → integrate_module-0.99.5/integrate_module.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: integrate_module
-Version: 0.99.2
+Version: 0.99.5
 Summary: Localized probabilistic data integration
 Author-email: Thomas Mejer Hansen <tmeha@geo.au.dk>
 License: MIT

{integrate_module-0.99.2 → integrate_module-0.99.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "integrate_module"
-version = "0.99.02"
+version = "0.99.5"
 description = "Localized probabilistic data integration"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.10"