integrate-module 0.97.0__tar.gz → 0.98.0__tar.gz

{integrate_module-0.97.0/integrate_module.egg-info → integrate_module-0.98.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: integrate_module
-Version: 0.97.0
+Version: 0.98.0
 Summary: Localized probabilistic data integration
 Author-email: Thomas Mejer Hansen <tmeha@geo.au.dk>
 License: MIT
@@ -26,6 +26,7 @@ Requires-Dist: jupyter>=1.0.0
 Requires-Dist: jupytext
 Requires-Dist: pandas
 Requires-Dist: pyvista
+Requires-Dist: litellm
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: black; extra == "dev"

{integrate_module-0.97.0 → integrate_module-0.98.0}/integrate/__init__.py

@@ -78,6 +78,7 @@ from integrate.integrate_io import check_data
 from integrate.integrate_io import merge_prior
 from integrate.integrate_io import merge_data
 from integrate.integrate_io import merge_posterior
+from integrate.integrate_io import filter_prior
 from integrate.integrate_io import read_usf
 from integrate.integrate_io import read_usf_mul
 from integrate.integrate_io import test_read_usf
@@ -124,6 +125,7 @@ from integrate.integrate_query import save_query
 from integrate.integrate_query import load_query
 from integrate.integrate_query import get_prior_model_info
 from integrate.integrate_query import query_from_text
+from integrate.integrate_query import query_test_llm
 
 # Import gex module functions
 from integrate.gex import read_gex as read_gex2

{integrate_module-0.97.0 → integrate_module-0.98.0}/integrate/integrate.py

@@ -337,7 +337,8 @@ def integrate_posterior_stats(f_post_h5='POST.h5', ip_range=None, **kwargs):
     - ``/Mx/Mean``          [Np, Nm]  Arithmetic mean of posterior realizations.
     - ``/Mx/LogMean``       [Np, Nm]  Geometric mean (exp of mean of log values).
     - ``/Mx/Median``        [Np, Nm]  Median of posterior realizations.
-    - ``/Mx/Std``           [Np, Nm]  Standard deviation of log10(posterior).
+    - ``/Mx/Std``           [Np, Nm]  Standard deviation of posterior realizations.
+    - ``/Mx/LogStd``        [Np, Nm]  Standard deviation of log10(posterior realizations).
     - ``/Mx/HarmonicMean``  [Np, Nm]  Trimmed harmonic mean: conductivity samples
       are trimmed 10% each tail, averaged, then inverted back to resistivity.
     - ``/Mx/KL``            [Np, Nm]  KL divergence in bits. Only written when
@@ -471,6 +472,7 @@ def integrate_posterior_stats(f_post_h5='POST.h5', ip_range=None, **kwargs):
                 M_logmean = np.full((nsounding, nm), np.nan)
                 M_mean = np.full((nsounding, nm), np.nan)
                 M_std = np.full((nsounding, nm), np.nan)
+                M_logstd = np.full((nsounding, nm), np.nan)
                 M_median = np.full((nsounding, nm), np.nan)
                 M_harmonicmean = np.full((nsounding, nm), np.nan)
                 if computeKL_continuous:
@@ -508,7 +510,8 @@ def integrate_posterior_stats(f_post_h5='POST.h5', ip_range=None, **kwargs):
                         M_mean[iid,:] = np.mean(m_post, axis=0)
                         M_median[iid,:] = np.median(m_post, axis=0)
                         with np.errstate(invalid='ignore', divide='ignore'):
-                            M_std[iid,:] = np.std(np.log10(np.maximum(m_post, 1e-10)), axis=0)
+                            M_logstd[iid,:] = np.std(np.log10(np.maximum(m_post, 1e-10)), axis=0)
+                        M_std[iid,:] = np.std(m_post, axis=0)
                         _c = 1.0 / np.maximum(m_post, 1e-10)
                         _k = int(np.floor(0.10 * _c.shape[0]))
                         _cs = np.sort(_c, axis=0)
@@ -563,10 +566,9 @@ def integrate_posterior_stats(f_post_h5='POST.h5', ip_range=None, **kwargs):
                         # Geometric Mean: exp(mean(log(x)))
                         M_logmean[current_iids, :] = np.exp(np.mean(log_cube, axis=1))
                         
-                        # Std of Log10:
-                        # Math identity: std(log10(x)) = std(ln(x) / ln(10)) = std(ln(x)) * (1/ln(10))
-                        # We reuse 'log_cube' and multiply by constant (faster than re-calculating log10)
-                        M_std[current_iids, :] = np.std(log_cube, axis=1) * INV_LOG_10
+                        # LogStd: std(log10(x)) = std(ln(x)) * (1/ln(10)); reuse log_cube for speed
+                        M_logstd[current_iids, :] = np.std(log_cube, axis=1) * INV_LOG_10
+                        M_std[current_iids, :] = np.std(m_cube, axis=1)
 
                         # Harmonic mean (trimmed 10% each tail in conductivity space)
                         _c = 1.0 / np.maximum(m_cube, 1e-10)
@@ -579,7 +581,7 @@ def integrate_posterior_stats(f_post_h5='POST.h5', ip_range=None, **kwargs):
 
 
                 # Create datasets
-                for stat in ['Mean', 'Median', 'Std', 'LogMean', 'HarmonicMean']:
+                for stat in ['Mean', 'Median', 'Std', 'LogStd', 'LogMean', 'HarmonicMean']:
                     if stat not in f_post:
                         dset = '/%s/%s' % (name,stat)
                         if dset not in f_post:
@@ -591,6 +593,7 @@ def integrate_posterior_stats(f_post_h5='POST.h5', ip_range=None, **kwargs):
                 f_post['/%s/%s' % (name,'Mean')][:] = M_mean
                 f_post['/%s/%s' % (name,'Median')][:] = M_median
                 f_post['/%s/%s' % (name,'Std')][:] = M_std
+                f_post['/%s/%s' % (name,'LogStd')][:] = M_logstd
                 f_post['/%s/%s' % (name,'HarmonicMean')][:] = M_harmonicmean
                 if computeKL_continuous:
                     dset = '/%s/KL' % name
@@ -1721,14 +1724,15 @@ def prior_model_layered(lay_dist='uniform', dz = 1, z_max = 90,
 
         # Apply boundaries if any exist
         if n_boundaries > 0:
-            boundaries = i_boundaries_all[i, :n_boundaries]
+            boundaries = np.sort(i_boundaries_all[i, :n_boundaries])
             for j in range(n_boundaries):
                 M_rho[i, boundaries[j]:] = rho_all[i, j + 1]
 
         # Save sparse representation if requested
         if save_sparse:
             if n_boundaries > 0:
-                m_current = np.concatenate((z_boundaries_all[i, :n_boundaries], rho_all[i, :n_lay]))
+                z_sorted = np.sort(z_boundaries_all[i, :n_boundaries])
+                m_current = np.concatenate((z_sorted, rho_all[i, :n_lay]))
             else:
                 m_current = rho_all[i, :n_lay]
             M_rho_sparse[i, 0:len(m_current)] = m_current
@@ -3031,7 +3035,7 @@ def allocate_large_page():
         return None
 
 
-def timing_compute(N_arr=[], Nproc_arr=[]):
+def timing_compute(N_arr=[], Nproc_arr=[], backend='numpy', NcpuForward=0):
     """
     Execute timing benchmark for INTEGRATE workflow components.
     
@@ -3046,7 +3050,11 @@ def timing_compute(N_arr=[], Nproc_arr=[]):
         Default is [100, 500, 1000, 5000, 10000, 50000, 100000, 500000, 1000000, 5000000].
     Nproc_arr : array_like, optional
         Array of processor counts to test. Default is powers of 2 up to available CPUs.
-        
+    NcpuForward : int, optional
+        Fixed number of CPUs to use for forward modeling. When > 0, forward modeling always
+        uses this many CPUs regardless of the current Nproc_arr entry. The inversion
+        (rejection sampling) still varies over Nproc_arr. Default is 0 (use Nproc_arr value).
+
     Returns
     -------
     str
@@ -3119,9 +3127,28 @@ def timing_compute(N_arr=[], Nproc_arr=[]):
 
     print("Testing on %d data sets of size(s):" % len(N_arr), N_arr)
     print("Testing on %d sets of core(s):" % len(Nproc_arr), Nproc_arr)
+    if NcpuForward > 0:
+        print("Forward modeling fixed to %d CPUs (inversion varies over Nproc_arr)" % NcpuForward)
 
 
-    file_out  = 'timing_%s-%s-%dcore_Nproc%d_N%d.npz' % (hostname,system,Ncpu,len(Nproc_arr), len(N_arr))
+    print("Rejection sampling backend: %s" % backend)
+    backend_label = backend
+    if backend == 'jax':
+        import os
+        jax_platform_env = os.environ.get('JAX_PLATFORMS', '').strip().lower()
+        if jax_platform_env in ('gpu', 'cuda', 'rocm'):
+            backend_label = 'jax_gpu'
+        elif jax_platform_env == 'cpu':
+            backend_label = 'jax_cpu'
+        else:
+            try:
+                import jax
+                jax_device = jax.default_backend()
+                backend_label = 'jax_gpu' if jax_device == 'gpu' else 'jax_cpu'
+            except Exception:
+                backend_label = 'jax_cpu'
+        print("JAX backend label: %s (JAX_PLATFORMS='%s')" % (backend_label, jax_platform_env))
+    file_out  = 'timing_%s-%s-%dcore_Nproc%d_N%d_%s.npz' % (hostname,system,Ncpu,len(Nproc_arr), len(N_arr), backend_label)
     print("Writing results to %s " % file_out)
 
     ## TIMING
@@ -3170,14 +3197,15 @@ def timing_compute(N_arr=[], Nproc_arr=[]):
                 #ig.plot_prior_stats(f_prior_h5)
                 #% A2. Compute prior DATA
                 t0_forward = time.time()
-                f_prior_data_h5 = ig.prior_data_gaaem(f_prior_h5, file_gex, Ncpu=Ncpu, showInfo=showInfo)
+                Ncpu_fwd = NcpuForward if NcpuForward > 0 else Ncpu
+                f_prior_data_h5 = ig.prior_data_gaaem(f_prior_h5, file_gex, Ncpu=Ncpu_fwd, showInfo=showInfo)
                 T_forward[i,j]=time.time()-t0_forward
 
                 #% READY FOR INVERSION
                 N_use = 1000000
                 t0_rejection = time.time()
                 if testRejection:
-                    f_post_h5 = ig.integrate_rejection(f_prior_data_h5, f_data_h5, N_use = N_use, parallel=1, updatePostStat=False,  Ncpu=Ncpu, showInfo=showInfo)
+                    f_post_h5 = ig.integrate_rejection(f_prior_data_h5, f_data_h5, N_use=N_use, parallel=1, updatePostStat=False, Ncpu=Ncpu, showInfo=showInfo, backend=backend)
                 T_rejection[i,j]=time.time()-t0_rejection
 
                 #% Compute some generic statistic of the posterior distribution (Mean, Median, Std)
@@ -3187,7 +3215,7 @@ def timing_compute(N_arr=[], Nproc_arr=[]):
                     T_poststat[i,j]=time.time()-t0_poststat
 
             T_total = T_prior + T_forward + T_rejection + T_poststat
-            np.savez(file_out, T_total=T_total, T_prior=T_prior, T_forward=T_forward, T_rejection=T_rejection, T_poststat=T_poststat, N_arr=N_arr, Nproc_arr=Nproc_arr, nobs=nobs)
+            np.savez(file_out, T_total=T_total, T_prior=T_prior, T_forward=T_forward, T_rejection=T_rejection, T_poststat=T_poststat, N_arr=N_arr, Nproc_arr=Nproc_arr, nobs=nobs, backend=backend)
             
             
     return file_out

{integrate_module-0.97.0 → integrate_module-0.98.0}/integrate/integrate_borehole.py

@@ -763,8 +763,8 @@ def get_weight_from_position(f_data_h5,x_well=0,y_well=0, i_ref=-1, r_dis = 400,
     w_data = np.exp(-1*sum_dd**2/r_data**2)
     
 
-    # COmpute the distance from d_ref to all other points
-    dis = np.sqrt((X-X[i_ref])**2 + (Y-Y[i_ref])**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_combined = w_data * w_dis

{integrate_module-0.97.0 → integrate_module-0.98.0}/integrate/integrate_io.py

@@ -2420,34 +2420,47 @@ def copy_prior(input_filename, output_filename, idx=None, N_use=None, loadtomem=
     return output_filename
 
 
-def filter_prior(f_prior_h5, type='nonnegative_data', id=1,
-                 f_prior_filtered_h5='', **kwargs):
+def filter_prior(f_prior_h5, index_use=None, *, type=None, id=1,
+                 f_prior_filtered_h5='', makeCopy=True, f_prior_out_h5=None, **kwargs):
     """
     Filter prior realizations and write the result to a new HDF5 file.
 
-    Removes rows (realizations) from all M and D datasets in a prior file
-    based on a criterion evaluated on a chosen D dataset. The filtered file
-    is a complete, self-consistent prior that can be used directly in place
-    of the original.
+    Removes rows (realizations) from all M and D datasets in a prior file,
+    either by supplying an explicit index array (``index_use``) or by applying
+    a named criterion to a D dataset (``type``). The filtered file is a
+    complete, self-consistent prior that can be used directly in place of the
+    original.
 
     Parameters
     ----------
     f_prior_h5 : str
         Path to the input prior HDF5 file.
+    index_use : array-like, optional
+        Explicit array of row indices to keep. When provided, ``type`` and
+        ``id`` are ignored. If ``None`` and ``makeCopy=True``, all rows are
+        kept (i.e. the result is a full copy). Default is ``None``.
     type : str, optional
-        Filter criterion to apply. Supported values:
+        Filter criterion used when ``index_use`` is ``None``. Supported values:
 
         ``'nonnegative_data'``
             Keep only realizations where every value in ``/D{id}`` is >= 0.
             Useful after forward modelling to remove unphysical responses.
 
-        Default is ``'nonnegative_data'``.
+        When ``None`` (default) and ``index_use`` is also ``None``, all rows
+        are kept (equivalent to a full copy).
     id : int, optional
-        Index of the D dataset used for filtering (e.g. ``id=1`` uses ``/D1``).
-        Default is 1.
+        Index of the D dataset used for criterion-based filtering
+        (e.g. ``id=1`` uses ``/D1``). Default is 1.
     f_prior_filtered_h5 : str, optional
-        Output filename. If empty, auto-generates as
-        ``<stem>_filtered_<type>.h5``. Default is ``''``.
+        Output filename (kept for backward compatibility). Superseded by
+        ``f_prior_out_h5`` when both are provided. Default is ``''``.
+    makeCopy : bool, optional
+        If ``True`` (default), write to a new file and leave the original
+        untouched. If ``False``, overwrite the original file in-place.
+    f_prior_out_h5 : str, optional
+        Output filename. Auto-generated when ``None`` (default):
+        ``<stem>_filtered_index.h5`` for index-based filtering or
+        ``<stem>_filtered_<type>.h5`` for criterion-based filtering.
     **kwargs
         showInfo : int, optional
             Verbosity level (default 0). Passed through to ``copy_prior``.
@@ -2460,50 +2473,73 @@ def filter_prior(f_prior_h5, type='nonnegative_data', id=1,
     Raises
     ------
     KeyError
-        If ``/D{id}`` is not found in the input file.
+        If ``/D{id}`` is not found in the input file (criterion mode only).
     ValueError
-        If an unknown ``type`` is specified.
+        If an unknown ``type`` is specified (criterion mode only).
 
     Examples
     --------
-    >>> f_prior_filtered = ig.filter_prior(f_prior_h5, type='nonnegative_data', id=1)
-
-    Notes
-    -----
-    Filtering is delegated to ``copy_prior``, which preserves all dataset
-    attributes and applies compression. New filter types can be added by
-    extending the ``if/elif`` block that computes ``idx``.
+    >>> f_out = ig.filter_prior(f_prior_h5, index_use=np.arange(1000))
+    >>> f_out = ig.filter_prior(f_prior_h5, type='nonnegative_data', id=1)
     """
     import numpy as np
     import os
 
     showInfo = kwargs.get('showInfo', 0)
 
-    if not f_prior_filtered_h5:
+    # Determine output path
+    if f_prior_out_h5 is not None:
+        out_file = f_prior_out_h5
+    elif f_prior_filtered_h5:
+        out_file = f_prior_filtered_h5
+    elif not makeCopy:
+        out_file = f_prior_h5 + '.tmp'
+    else:
         stem = os.path.splitext(f_prior_h5)[0]
-        f_prior_filtered_h5 = '%s_filtered_%s.h5' % (stem, type)
+        if index_use is not None:
+            out_file = '%s_filtered_index.h5' % stem
+        elif type is not None:
+            out_file = '%s_filtered_%s.h5' % (stem, type)
+        else:
+            out_file = '%s_filtered.h5' % stem
 
-    Dname = '/D%d' % id
+    # Determine indices
+    if index_use is not None:
+        idx = np.asarray(index_use)
+        with h5py.File(f_prior_h5, 'r') as f:
+            first = next(k for k in f if isinstance(f[k], h5py.Dataset))
+            N_in = f[first].shape[0]
+        N_out = len(idx)
+        if showInfo >= 0:
+            print("filter_prior [index_use]: keeping %d / %d realizations (%.1f%%)"
+                  % (N_out, N_in, 100.0 * N_out / N_in))
+    elif type is not None:
+        Dname = '/D%d' % id
+        with h5py.File(f_prior_h5, 'r') as f:
+            if Dname not in f:
+                raise KeyError("Dataset '%s' not found in %s" % (Dname, f_prior_h5))
+            D = f[Dname][:]
 
-    with h5py.File(f_prior_h5, 'r') as f:
-        if Dname not in f:
-            raise KeyError("Dataset '%s' not found in %s" % (Dname, f_prior_h5))
-        D = f[Dname][:]
+        if type == 'nonnegative_data':
+            idx = np.where(np.all(D >= 0, axis=1))[0]
+        else:
+            raise ValueError("Unknown filter type: '%s'" % type)
 
-    if type == 'nonnegative_data':
-        idx = np.where(np.all(D >= 0, axis=1))[0]
+        N_in = D.shape[0]
+        N_out = len(idx)
+        if showInfo >= 0:
+            print("filter_prior [%s on %s]: keeping %d / %d realizations (%.1f%%)"
+                  % (type, Dname, N_out, N_in, 100.0 * N_out / N_in))
     else:
-        raise ValueError("Unknown filter type: '%s'" % type)
+        idx = None
 
-    N_in = D.shape[0]
-    N_out = len(idx)
-    if showInfo >= 0:
-        print("filter_prior [%s on %s]: keeping %d / %d realizations (%.1f%%)"
-              % (type, Dname, N_out, N_in, 100.0 * N_out / N_in))
+    copy_prior(f_prior_h5, out_file, idx=idx, **kwargs)
 
-    copy_prior(f_prior_h5, f_prior_filtered_h5, idx=idx, **kwargs)
+    if not makeCopy:
+        os.replace(out_file, f_prior_h5)
+        return f_prior_h5
 
-    return f_prior_filtered_h5
+    return out_file
 
 
 def hdf5_scan(file_path):
@@ -2736,7 +2772,6 @@ def get_case_data(case='DAUGAARD', loadAll=False, loadType='', filelist=None, **
             filelist.append('TX07_20230828_2x4_RC20-33.gex')
             filelist.append('TX07_20230906_2x4_RC20-33.gex')
             filelist.append('TX07_20231016_2x4_RC20-33.gex')
-
             
         if (loadAll or loadType=='shapefiles'):            
             #filelist.append('Begravet dal.zip')
@@ -2770,6 +2805,22 @@ def get_case_data(case='DAUGAARD', loadAll=False, loadType='', filelist=None, **
             filelist.append('POST_DAUGAARD_AVG_prior_detailed_outvalleys_N2000000_dmax90_TX07_20231016_2x4_RC20-33_Nh280_Nf12_Nu2000000_aT1.h5')    
             filelist.append('prior_detailed_inout_N4000000_dmax90_TX07_20231016_2x4_RC20-33_Nh280_Nf12.h5')
 
+        if (loadAll or loadType=='WB_sharp'):
+            filelist.append('SCI7_40_ml_sharp2_I02_MOD_syn.xyz')
+            filelist.append('SCI7_40_ml_sharp2_I02_MOD_dat.xyz')
+            filelist.append('SCI7_40_ml_sharp2_I02_MOD_inv.xyz')
+            filelist.append('SCI7_40_ml_sharp2_I02_MOD.xyz')
+            filelist.append('SCI7_40_ml_sharp2_Daugaard.gdb')
+        
+        if (loadAll or loadType=='WB_smooth'):
+            filelist.append('SCI7_40_ml_Daugaard_I01_MOD_syn.xyz')
+            filelist.append('SCI7_40_ml_Daugaard_I01_MOD_dat.xyz')
+            filelist.append('SCI7_40_ml_Daugaard_I01_MOD_inv.xyz')
+            filelist.append('SCI7_40_ml_Daugaard_I01_MOD.xyz')
+            filelist.append('SCI7_40_ml_Daugaard_I01.gdb')
+
+
+
     elif case=='ESBJERG':
 
         if len(filelist)==0:
@@ -2900,8 +2951,10 @@ def get_case_data(case='DAUGAARD', loadAll=False, loadType='', filelist=None, **
         filelist.append('20240911_eksterngps_AVG_export.xyz')      
         filelist.append('20241210_AVG_export.xyz')
         filelist.append('20241210_InternGPS_AVG_export.xyz')
-        filelist.append('Sdr_Felding_prior_standard_N1000000_dmax90_20260417_0929.h5')
+        #filelist.append('Sdr_Felding_prior_standard_N1000000_dmax90_20260417_0929.h5')
+        #filelist.append('Sdr_Felding_prior_240426_N1000000_dmax90_20260424_1521.h5')
         filelist.append('SdrFelding_boreholes.json')
+        filelist.append('Sdr_Felding_prior_210526_N1000000_dmax90_20260521_1616.h5')  
 
 
         
@@ -4793,7 +4846,7 @@ def _analyze_data_file(f, print_line, load_data=False):
     print_line()
 
     # Data groups
-    data_groups = sorted([key for key in f.keys() if key.startswith('D') and len(key) == 2])
+    data_groups = sorted([key for key in f.keys() if key.startswith('D') and key[1:].isdigit()], key=lambda k: int(k[1:]))
     print_line(f"Data Groups: {len(data_groups)} found", 0)
     print_line()
 
@@ -4834,7 +4887,7 @@ def _analyze_prior_file(f, print_line, load_data=False):
 
     # Determine number of realizations
     N = None
-    model_keys = sorted([key for key in f.keys() if key.startswith('M') and len(key) == 2])
+    model_keys = sorted([key for key in f.keys() if key.startswith('M') and key[1:].isdigit()], key=lambda k: int(k[1:]))
     if model_keys:
         N = f[model_keys[0]].shape[0]
 
@@ -4894,7 +4947,7 @@ def _analyze_prior_file(f, print_line, load_data=False):
         print_line()
 
     # Data groups
-    data_groups = sorted([key for key in f.keys() if key.startswith('D') and len(key) == 2])
+    data_groups = sorted([key for key in f.keys() if key.startswith('D') and key[1:].isdigit()], key=lambda k: int(k[1:]))
     print_line(f"Data Realizations: {len(data_groups)} found", 0)
     print_line()
 
@@ -4980,7 +5033,7 @@ def _analyze_post_file(f, print_line, load_data=False):
     print_line()
 
     # Model statistics
-    model_keys = sorted([key for key in f.keys() if key.startswith('M') and len(key) == 2])
+    model_keys = sorted([key for key in f.keys() if key.startswith('M') and key[1:].isdigit()], key=lambda k: int(k[1:]))
     print_line(f"Model Parameter Statistics: {len(model_keys)} found", 0)
     print_line()
 

{integrate_module-0.97.0 → integrate_module-0.98.0}/integrate/integrate_plot.py

@@ -1465,6 +1465,9 @@ def plot_profile_discrete(f_post_h5, i1=1, i2=1e+9, ii=np.array(()), im=1, xaxis
         If True, plot KL divergence instead of entropy in the entropy panel.
         KL is plotted only if the ``/Mx/KL`` dataset exists; otherwise entropy
         is used as fallback (default False).
+    fontsize : int or float, optional
+        Font size applied to all text elements (titles, axis labels, colorbar labels,
+        tick labels). If None, matplotlib's current default is used (default None).
 
     Returns
     -------
@@ -1525,6 +1528,7 @@ def plot_profile_discrete(f_post_h5, i1=1, i2=1e+9, ii=np.array(()), im=1, xaxis
     entropy_max = kwargs.get('entropy_max', None)  # Will set default after loading Entropy
     show_n_unique = kwargs.get('show_n_unique', False)  # Show number of unique realizations
     plot_kl = kwargs.get('plot_kl', False)  # Plot KL divergence instead of entropy
+    fontsize = kwargs.get('fontsize', None)
 
     # Default to showing all panels
     if panels is None:
@@ -1942,8 +1946,16 @@ def plot_profile_discrete(f_post_h5, i1=1, i2=1e+9, ii=np.array(()), im=1, xaxis
         else:
             ax[2].legend(loc='upper right')
 
+        ax[2].set_xlabel({'x': 'X (m)', 'y': 'Y (m)', 'id': 'ID', 'index': 'Index'}.get(xaxis, xaxis))
         plt.grid(True)
 
+    if fontsize is not None:
+        import matplotlib.text as _mtext
+        for _t in fig.findobj(_mtext.Text):
+            _t.set_fontsize(fontsize)
+        for _ax in fig.get_axes():
+            _ax.tick_params(labelsize=fontsize)
+
     plt.tight_layout()
 
     # Create an invisible colorbar for the last subplot to maintain alignment
@@ -2009,13 +2021,15 @@ def plot_profile_continuous(f_post_h5, i1=1, i2=1e+9, ii=np.array(()), im=1, xax
         - ['std']: Only standard deviation
         - ['stats']: Only temperature and log-likelihood
         - Any combination of the above (e.g., ['value', 'stats'])
-        Accepted panel names: 'value', 'median', 'mean', 'std', 'uncertainty', 'stats', 'temperature', 't'
+        Accepted panel names: 'value', 'median', 'mean', 'harmonicmean', 'std', 'uncertainty', 'stats', 'temperature', 't'
+        Using a statistic name (``'median'``, ``'mean'``, ``'harmonicmean'``) as the panel name also
+        selects that statistic as the plotted value, overriding the default ``key``.
     hardcopy : bool, optional
         Save plot as PNG file (default False).
     cmap : str or colormap, optional
         Color scheme for plotting (default ``'jet'``).
     key : str, optional
-        Statistic to plot: ``'Mean'``, ``'Median'``, or ``'HarmonicMean'`` (default ``'Median'``).
+        Statistic to plot in the value panel: ``'Mean'``, ``'Median'``, or ``'HarmonicMean'`` (default ``'HarmonicMean'``).
     alpha : float, optional
         Transparency scaling factor based on normalized standard deviation (0.0=no
         transparency, default; 1.0=full uncertainty-based transparency).
@@ -2036,6 +2050,9 @@ def plot_profile_continuous(f_post_h5, i1=1, i2=1e+9, ii=np.array(()), im=1, xax
     plot_kl : bool, optional
         If True, plot KL divergence instead of standard deviation in the std panel.
         Falls back to Std if ``/Mx/KL`` does not exist (default False).
+    fontsize : int or float, optional
+        Font size applied to all text elements (titles, axis labels, colorbar labels,
+        tick labels). If None, matplotlib's current default is used (default None).
 
     Returns
     -------
@@ -2083,11 +2100,12 @@ def plot_profile_continuous(f_post_h5, i1=1, i2=1e+9, ii=np.array(()), im=1, xax
     kwargs.setdefault('clim', None)
 
     alpha = kwargs.get('alpha',0.0)
-    key = kwargs.get('key','Median')
+    key = kwargs.get('key','HarmonicMean')
     txt = kwargs.get('txt','')
     showInfo = kwargs.get('showInfo', 0)
     show_n_unique = kwargs.get('show_n_unique', False)  # Show number of unique realizations
     plot_kl = kwargs.get('plot_kl', False)  # Plot KL divergence instead of Std
+    fontsize = kwargs.get('fontsize', None)
 
     # Default to showing all panels
     if panels is None:
@@ -2096,8 +2114,17 @@ def plot_profile_continuous(f_post_h5, i1=1, i2=1e+9, ii=np.array(()), im=1, xax
     # Normalize panel names to lowercase
     panels = [p.lower() for p in panels]
 
+    # Infer key from panel name if not explicitly provided
+    if 'key' not in kwargs:
+        if 'median' in panels:
+            key = 'Median'
+        elif 'mean' in panels:
+            key = 'Mean'
+        elif 'harmonicmean' in panels:
+            key = 'HarmonicMean'
+
     # Determine which panels to show
-    show_value = any(p in panels for p in ['value', 'median', 'mean'])
+    show_value = any(p in panels for p in ['value', 'median', 'mean', 'harmonicmean'])
     show_std = any(p in panels for p in ['std', 'uncertainty'])
     show_stats = any(p in panels for p in ['stats', 't', 'temperature'])
     
@@ -2162,6 +2189,10 @@ def plot_profile_continuous(f_post_h5, i1=1, i2=1e+9, ii=np.array(()), im=1, xax
         except KeyError:
             HarmonicMean=None
         Std=f_post[Mstr+'/Std'][:].T
+        try:
+            LogStd=f_post[Mstr+'/LogStd'][:].T
+        except KeyError:
+            LogStd=None
         T=f_post['/T'][:].T
         try:
             CHI2=f_post['/CHI2'][:]
@@ -2492,7 +2523,8 @@ def plot_profile_continuous(f_post_h5, i1=1, i2=1e+9, ii=np.array(()), im=1, xax
             fig.colorbar(im3, ax=ax[isp], label='KL Divergence (bits)')
         else:
             # STD
-            std_data = Std[:,ii]
+            std_src = LogStd if LogStd is not None else Std
+            std_data = std_src[:,ii]
             if gap_alpha is not None:
                 std_data = np.ma.masked_where(gap_alpha == 0.0, std_data)
             std_cmap, _ = get_colormap_and_limits('entropy')
@@ -2500,9 +2532,10 @@ def plot_profile_continuous(f_post_h5, i1=1, i2=1e+9, ii=np.array(()), im=1, xax
                         cmap=std_cmap,
                         shading='auto')
             im3.set_clim(0,1)
-            ax[isp].set_title('Std %s' % name)
+            std_label = 'LogStd' if LogStd is not None else 'log₁₀ Std'
+            ax[isp].set_title('LogStd %s' % name)
             ax[isp].set_ylabel('Elevation (m)')
-            fig.colorbar(im3, ax=ax[isp], label='Standard deviation (Ohm.m)')
+            fig.colorbar(im3, ax=ax[isp], label=std_label)
 
     # Handle single parameter case (nm <= 1)
     if show_value and nm<=1:
@@ -2579,8 +2612,16 @@ def plot_profile_continuous(f_post_h5, i1=1, i2=1e+9, ii=np.array(()), im=1, xax
         else:
             ax[2].legend(loc='upper right')
 
+        ax[2].set_xlabel({'x': 'X (m)', 'y': 'Y (m)', 'id': 'ID', 'index': 'Index'}.get(xaxis, xaxis))
         plt.grid(True)
 
+    if fontsize is not None:
+        import matplotlib.text as _mtext
+        for _t in fig.findobj(_mtext.Text):
+            _t.set_fontsize(fontsize)
+        for _ax in fig.get_axes():
+            _ax.tick_params(labelsize=fontsize)
+
     plt.tight_layout()
 
     if show_stats and nm>1: