integrate_module 0.99.5__tar.gz → 0.99.6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: integrate_module
-Version: 0.99.5
+Version: 0.99.6
 Summary: Localized probabilistic data integration
 Author-email: Thomas Mejer Hansen <tmeha@geo.au.dk>
 License: MIT
@@ -34,6 +34,13 @@ Requires-Dist: jax
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: black; extra == "dev"
+Provides-Extra: ml
+Requires-Dist: tensorflow; extra == "ml"
+Requires-Dist: scikit-learn; extra == "ml"
+Requires-Dist: keras_tuner; extra == "ml"
+Provides-Extra: examples
+Requires-Dist: geopandas; extra == "examples"
+Requires-Dist: shapely; extra == "examples"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: nbsphinx; extra == "docs"
@@ -43,6 +50,8 @@ Requires-Dist: myst-parser; extra == "docs"
 Requires-Dist: sphinx-rtd-theme; extra == "docs"
 Requires-Dist: furo; extra == "docs"
 Requires-Dist: tomli; python_version < "3.11" and extra == "docs"
+Provides-Extra: jax-cuda
+Requires-Dist: jax[cuda12]; extra == "jax-cuda"
 Dynamic: license-file
 
 # INTEGRATE Python Module

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

@@ -3240,7 +3240,7 @@ def save_data_gaussian(D_obs, D_std = [], d_std=[], Cd=[], id=1, id_prior=None,
     return f_data_h5
 
 
-def xyz_to_h5(file_xyz, file_gex, f_data_h5=None, i_lm_skip=None, i_hm_skip=None, nan_value=None, showInfo=0, disregardFullNan=True, data_obs=None, data_std=None):
+def xyz_to_h5(file_xyz, file_gex, f_data_h5=None, i_lm_skip=None, i_hm_skip=None, nan_value=None, showInfo=0, disregardFullNan=True, data_obs=None, data_std=None, altitude=None, altitude_std=None, tx_altitude=None, tx_altitude_std=None, rx_altitude=None, rx_altitude_std=None):
     """
     Convert Aarhus Workbench XYZ export file(s) to an INTEGRATE HDF5 data file.
 
@@ -3292,6 +3292,38 @@ def xyz_to_h5(file_xyz, file_gex, f_data_h5=None, i_lm_skip=None, i_hm_skip=None
         same length as ``data_obs``.  Use ``None`` for an individual entry to
         fall back to ``0.05 * |d_obs|`` for that column.  If the whole
         parameter is omitted, all columns default to ``0.05 * |d_obs|``.
+    altitude : str, optional
+        Flightlines column name (case-insensitive) holding the platform's
+        flight altitude/height, e.g. ``'Alt'``.  When given, written as its
+        own Gaussian data block with ``id=2`` (the second dataset, after the
+        ``/D1`` dbdt data).  Any ``data_obs`` columns are then written
+        starting at ``id=3`` instead of ``id=2``.
+    altitude_std : str, float, or None, optional
+        Uncertainty for ``altitude``.
+        - A **string** is treated as another flightlines column name
+          (case-insensitive) holding the absolute std directly.
+        - A **number** with ``abs(altitude_std) < 1`` is treated as a
+          *relative* std: ``std = altitude_std * altitude``.
+        - A **number** with ``abs(altitude_std) >= 1`` is treated as an
+          *absolute* std in meters, constant for all soundings.
+        - If ``None`` (default), falls back to ``0.05 * |altitude|``.
+    tx_altitude : str, optional
+        Flightlines column name (case-insensitive) holding the transmitter
+        altitude/height. When given, written as its own Gaussian data block,
+        immediately after ``altitude`` (if also given). Optional — omitted
+        entirely if not given.
+    tx_altitude_std : str, float, or None, optional
+        Uncertainty for ``tx_altitude``. Same rules as ``altitude_std``
+        (string column name / relative number / absolute number / default
+        5% relative if ``None``). Only used if ``tx_altitude`` is given.
+    rx_altitude : str, optional
+        Flightlines column name (case-insensitive) holding the receiver
+        altitude/height. When given, written as its own Gaussian data block,
+        after ``altitude`` and ``tx_altitude`` (if also given). Optional —
+        omitted entirely if not given.
+    rx_altitude_std : str, float, or None, optional
+        Uncertainty for ``rx_altitude``. Same rules as ``altitude_std``.
+        Only used if ``rx_altitude`` is given.
 
     Returns
     -------
@@ -3380,9 +3412,22 @@ def xyz_to_h5(file_xyz, file_gex, f_data_h5=None, i_lm_skip=None, i_hm_skip=None
     ld = {k: pd.concat([xyz.layer_data[k] for xyz in xyz_list], ignore_index=True)
           for k in xyz_list[0].layer_data}
 
-    # Handle XYZ files that use 'x'/'y' instead of 'utmx'/'utmy'
+    # Handle XYZ files that use alternate column names for geometry
+    # (e.g. tTEM: utmx/utmy/line_no/elevation, SkyTEM: e/n/line/dem)
     if 'utmx' not in fl.columns and 'x' in fl.columns:
         fl = fl.rename(columns={'x': 'utmx', 'y': 'utmy'})
+    if 'utmx' not in fl.columns and 'e' in fl.columns:
+        fl = fl.rename(columns={'e': 'utmx', 'n': 'utmy'})
+    if 'line_no' not in fl.columns and 'line' in fl.columns:
+        fl = fl.rename(columns={'line': 'line_no'})
+    if 'elevation' not in fl.columns and 'dem' in fl.columns:
+        fl = fl.rename(columns={'dem': 'elevation'})
+
+    # Handle single-channel XYZ files (e.g. SkyTEM) that store the sounding
+    # data under a plain component name instead of the tTEM 'ch1gt' naming
+    if 'dbdt_ch1gt' not in ld and 'z_dbdt' in ld:
+        ld['dbdt_ch1gt'] = ld['z_dbdt']
+        ld['dbdt_std_ch1gt'] = ld['relunc_z_dbdt']
 
     # Determine dummy/missing value: explicit arg > XYZ header > fallback 9999
     if nan_value is None:
@@ -3393,7 +3438,12 @@ def xyz_to_h5(file_xyz, file_gex, f_data_h5=None, i_lm_skip=None, i_hm_skip=None
     # --- pair ch1 / ch2 rows (mirrors MATLAB logic) ---
     # Every ch1 row becomes a sounding.  HM data is filled where the
     # immediately following row is ch2; otherwise those columns stay NaN.
-    channel_arr = fl['channel_no'].values
+    # Single-channel systems (e.g. SkyTEM) have no 'channel_no' column at
+    # all: every row is its own (channel-1) sounding.
+    if 'channel_no' in fl.columns:
+        channel_arr = fl['channel_no'].values
+    else:
+        channel_arr = np.ones(len(fl))
     ch1_pos = np.where(channel_arr == 1)[0]
 
     # geometry from channel-1 rows (all of them)
@@ -3475,7 +3525,38 @@ def xyz_to_h5(file_xyz, file_gex, f_data_h5=None, i_lm_skip=None, i_hm_skip=None
         if n_channels >= 2:
             hf.create_dataset('/D1/i_hm', data=np.arange(i_hm_start, i_hm_end))
 
-    # --- write additional data columns as D2, D3, ... ---
+    # --- write altitude / rx_altitude / tx_altitude (if given) as their own Gaussian data blocks ---
+    def _resolve_std(obs, std_arg):
+        if isinstance(std_arg, str):
+            return fl[std_arg.lower()].values[ch1_pos][keep].reshape(-1, 1).astype(float)
+        elif isinstance(std_arg, (int, float)):
+            if abs(std_arg) < 1:
+                return std_arg * np.abs(obs)  # relative
+            else:
+                return np.full_like(obs, float(std_arg))  # absolute, meters
+        else:
+            return 0.05 * np.abs(obs)  # default: 5% relative
+
+    next_id = 2
+    for col, col_std, name in (
+        (altitude, altitude_std, 'Altitude'),
+        (tx_altitude, tx_altitude_std, 'Tx_altitude'),
+        (rx_altitude, rx_altitude_std, 'Rx_altitude'),
+    ):
+        if col is not None:
+            obs = fl[col.lower()].values[ch1_pos][keep].reshape(-1, 1).astype(float)
+            std = _resolve_std(obs, col_std)
+            save_data_gaussian(
+                obs, D_std=std,
+                f_data_h5=f_data_h5,
+                id=next_id,
+                name=name,
+                delete_if_exist=False,
+                showInfo=showInfo,
+            )
+            next_id += 1
+
+    # --- write additional data columns as D2, D3, ... (or shifted if altitude present) ---
     if data_obs is not None:
         _data_std = data_std if data_std is not None else [None] * len(data_obs)
         for i, col_obs in enumerate(data_obs):
@@ -3488,7 +3569,7 @@ def xyz_to_h5(file_xyz, file_gex, f_data_h5=None, i_lm_skip=None, i_hm_skip=None
             save_data_gaussian(
                 obs, D_std=std,
                 f_data_h5=f_data_h5,
-                id=i + 2,
+                id=next_id + i,
                 name=col_obs,
                 delete_if_exist=False,
                 showInfo=showInfo,

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

@@ -2902,20 +2902,23 @@ def plot_discrete_data_entropy(f_data_h5, id_list, depth_reduce='min', **kwargs)
     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):
+def plot_data(f_data_h5, i_plot=[], Dkey=[], id=None, plType='imshow', uselog=True, **kwargs):
     """
     Plot observational data from an HDF5 file.
-    
+
     This function creates visualizations of electromagnetic data including time-series plots,
     2D image displays, and other data representations. Supports multiple data types and
     plotting styles for comprehensive data analysis.
-    
+
     :param f_data_h5: Path to the HDF5 file containing observational data
     :type f_data_h5: str
     :param i_plot: Indices of data points to plot. If empty, plots all available data
     :type i_plot: list or array-like, optional
     :param Dkey: Data keys/identifiers to plot. If empty, uses all available datasets
     :type Dkey: str or list, optional
+    :param id: Dataset id to plot (e.g. id=1 plots only 'D1'). If None (default) and
+        Dkey is also unset, every dataset found in the file (D1, D2, ...) is plotted.
+    :type id: int, optional
     :param plType: Plotting method - 'imshow' for 2D image display, 'plot' for line plots
     :type plType: str, optional
     :param uselog: Apply logarithmic scaling to data visualization (default is True)
@@ -2947,155 +2950,162 @@ def plot_data(f_data_h5, i_plot=[], Dkey=[], plType='imshow', uselog=True, **kwa
         return
 
 
+    # set plot in kwarg to True if not already set
+    if 'hardcopy' not in kwargs:
+        kwargs['hardcopy'] = True
+
     with h5py.File(f_data_h5,'r') as f_data:
 
-        if len(Dkey)==0:
-            nd = 0
+        if id is not None:
+            Dkeys = ['D%d' % id]
+        elif len(Dkey)==0:
             Dkeys = []
             for key in f_data.keys():
                 if key[0]=='D':
                     if showInfo>0:
                         print("plot_data: Found data set %s" % key)
                     Dkeys.append(key)
-                nd += 1
-            Dkey=Dkeys[0]
             if showInfo>0:
-                print("plot_data: Using data set %s" % Dkey)
+                print("plot_data: Using data set(s) %s" % Dkeys)
+        elif isinstance(Dkey, str):
+            Dkeys = [Dkey]
+        else:
+            Dkeys = list(Dkey)
 
-        noise_model = f_data['/%s' % Dkey].attrs['noise_model']
+        for Dkey in Dkeys:
+            noise_model = f_data['/%s' % Dkey].attrs['noise_model']
 
-        # Get name attribute if it exists
-        name_attr = f_data['/%s' % Dkey].attrs.get('name', None)
+            # Get name attribute if it exists
+            name_attr = f_data['/%s' % Dkey].attrs.get('name', None)
 
-        # Force plot type for discrete/multinomial data
-        if noise_model == 'multinomial' or Dkey.upper() in ['D2', 'D3', 'D4', 'D5']:
-            plType = 'plot'
+            # Force plot type for discrete/multinomial data
+            cur_plType = plType
+            if noise_model == 'multinomial' or Dkey.upper() in ['D2', 'D3', 'D4', 'D5']:
+                cur_plType = 'plot'
 
-        if noise_model == 'gaussian':
-            noise_model = 'Gaussian'
-            d_obs = f_data['/%s' % Dkey]['d_obs'][:]
-            d_std = f_data['/%s' % Dkey]['d_std'][:]
+            if noise_model == 'gaussian':
+                noise_model = 'Gaussian'
+                d_obs = f_data['/%s' % Dkey]['d_obs'][:]
+                d_std = f_data['/%s' % Dkey]['d_std'][:]
 
 
-            ndata,ns = f_data['/%s' % Dkey]['d_obs'].shape
-            # set i_plot as an array from 0 to ndata
-            if len(i_plot)==0:
-                i_plot = np.arange(ndata)
-                #i_plot = 1000+np.arange(5000)
+                ndata,ns = f_data['/%s' % Dkey]['d_obs'].shape
+                # set i_plot_cur as an array from 0 to ndata
+                if len(i_plot)==0:
+                    i_plot_cur = np.arange(ndata)
+                else:
+                    i_plot_cur = np.asarray(i_plot)
 
-            # remove all values in i_plot that are larger than the number of data
-            i_plot = i_plot[i_plot<ndata]
-            # remove all values in i_plot that are smaller than 0
-            i_plot = i_plot[i_plot>=0]
+                # remove all values in i_plot_cur that are larger than the number of data
+                i_plot_cur = i_plot_cur[i_plot_cur<ndata]
+                # remove all values in i_plot_cur that are smaller than 0
+                i_plot_cur = i_plot_cur[i_plot_cur>=0]
 
-            # find number of nan values on d_obs
-            non_nan = np.sum(~np.isnan(d_obs), axis=1)
+                # find number of nan values on d_obs
+                non_nan = np.sum(~np.isnan(d_obs), axis=1)
 
-            # Calculate the extent
-            # extent = [left, right, bottom, top]; imshow row 0 maps to top,
-            # so bottom=N_gates and top=0 gives gate 0 at the top of the plot
-            # with the y-axis label reading 0→N_gates from top to bottom.
-            xlim = [i_plot.min(), i_plot.max()]
-            extent = [xlim[0], xlim[1], d_obs.shape[1], 1]
+                # Calculate the extent
+                # extent = [left, right, bottom, top]; imshow row 0 maps to top,
+                # so bottom=N_gates and top=0 gives gate 0 at the top of the plot
+                # with the y-axis label reading 0→N_gates from top to bottom.
+                xlim = [i_plot_cur.min(), i_plot_cur.max()]
+                extent = [xlim[0], xlim[1], d_obs.shape[1], 1]
 
-            # plot figure with data
+                # plot figure with data
 
-            fig, ax = plt.subplots(4,1,figsize=(10,12), gridspec_kw={'height_ratios': [3, 3, 3, 1]})
+                fig, ax = plt.subplots(4,1,figsize=(10,12), gridspec_kw={'height_ratios': [3, 3, 3, 1]})
 
-            # Set suptitle with optional name attribute
+                # Set suptitle with optional name attribute
 
-            if plType=='plot':
-                if uselog:
-                    im1 = ax[0].semilogy(d_obs[i_plot,:], linewidth=.5)
-                    im2 = ax[1].semilogy(d_std[i_plot,:], linewidth=.5)
-                    im3 = ax[2].semilogy((d_obs[i_plot,:]/d_std[i_plot,:]), linewidth=.5)
-                else:
-                    im1 = ax[0].plot(d_obs[i_plot,:], linewidth=.5)
-                    im2 = ax[1].plot(d_std[i_plot,:], linewidth=.5)
-                    im3 = ax[2].plot(100.0 * d_std[i_plot,:]/d_obs[i_plot,:], linewidth=.5)
-                ax[0].set_xlim(xlim)
-                ax[1].set_xlim(xlim)
-                ax[2].set_xlim(xlim)
-                ax[2].set_ylim([0, 20])
-                ax[0].set_ylabel('d_obs')
-                ax[1].set_ylabel('d_std')
-                ax[2].set_ylabel('Relative noise [%] (d_std/d_obs × 100)')
-
-            elif plType=='imshow':
-                def _masked(arr):
-                    """Mask NaN, inf, and non-positive values; leave positives intact."""
-                    return np.ma.masked_where(~np.isfinite(arr) | (arr <= 0), arr)
-
-                def _cmap_white_bad(name):
-                    cmap = matplotlib.colormaps[name].copy()
-                    cmap.set_bad('white')
-                    return cmap
-
-                if uselog:
-                    im1 = ax[0].imshow(_masked(d_obs[i_plot,:]).T, aspect='auto',
-                                       cmap=_cmap_white_bad('jet_r'),
-                                       norm=matplotlib.colors.LogNorm(), extent=extent)
-                    im2 = ax[1].imshow(_masked(d_std[i_plot,:]).T, aspect='auto',
-                                       cmap=_cmap_white_bad('hot_r'),
-                                       norm=matplotlib.colors.LogNorm(), extent=extent)
+                if cur_plType=='plot':
+                    if uselog:
+                        im1 = ax[0].semilogy(d_obs[i_plot_cur,:], linewidth=.5)
+                        im2 = ax[1].semilogy(d_std[i_plot_cur,:], linewidth=.5)
+                        im3 = ax[2].semilogy((d_obs[i_plot_cur,:]/d_std[i_plot_cur,:]), linewidth=.5)
+                    else:
+                        im1 = ax[0].plot(d_obs[i_plot_cur,:], linewidth=.5)
+                        im2 = ax[1].plot(d_std[i_plot_cur,:], linewidth=.5)
+                        im3 = ax[2].plot(100.0 * d_std[i_plot_cur,:]/d_obs[i_plot_cur,:], linewidth=.5)
+                    ax[0].set_xlim(xlim)
+                    ax[1].set_xlim(xlim)
+                    ax[2].set_xlim(xlim)
+                    ax[2].set_ylim([0, 20])
+                    ax[0].set_ylabel('d_obs')
+                    ax[1].set_ylabel('d_std')
+                    ax[2].set_ylabel('Relative noise [%] (d_std/d_obs × 100)')
+
+                elif cur_plType=='imshow':
+                    def _masked(arr):
+                        """Mask NaN, inf, and non-positive values; leave positives intact."""
+                        return np.ma.masked_where(~np.isfinite(arr) | (arr <= 0), arr)
+
+                    def _cmap_white_bad(name):
+                        cmap = matplotlib.colormaps[name].copy()
+                        cmap.set_bad('white')
+                        return cmap
+
+                    if uselog:
+                        im1 = ax[0].imshow(_masked(d_obs[i_plot_cur,:]).T, aspect='auto',
+                                           cmap=_cmap_white_bad('jet_r'),
+                                           norm=matplotlib.colors.LogNorm(), extent=extent)
+                        im2 = ax[1].imshow(_masked(d_std[i_plot_cur,:]).T, aspect='auto',
+                                           cmap=_cmap_white_bad('hot_r'),
+                                           norm=matplotlib.colors.LogNorm(), extent=extent)
+                    else:
+                        im1 = ax[0].imshow(np.ma.masked_invalid(d_obs[i_plot_cur,:]).T,
+                                           aspect='auto', cmap=_cmap_white_bad('jet_r'), extent=extent)
+                        im2 = ax[1].imshow(np.ma.masked_invalid(d_std[i_plot_cur,:]).T,
+                                           aspect='auto', cmap=_cmap_white_bad('hot_r'), extent=extent)
+
+                    # Relative noise in % — mask invalid entries
+                    rel_noise = np.ma.masked_invalid(100.0 * d_std[i_plot_cur,:] / d_obs[i_plot_cur,:])
+                    im3 = ax[2].imshow(rel_noise.T, aspect='auto', vmin=0, vmax=20,
+                                       cmap=_cmap_white_bad('turbo'), extent=extent)
+
+                    fig.colorbar(im1, ax=ax[0])
+                    fig.colorbar(im2, ax=ax[1])
+                    fig.colorbar(im3, ax=ax[2])
+
+                    ax[0].set_ylabel('gate number')
+                    ax[1].set_ylabel('gate number')
+                    ax[2].set_ylabel('gate number')
+
+                    ax[0].set_title('d_obs: observed data')
+                    ax[1].set_title('d_std: standard deviation')
+                    ax[2].set_title('Relative noise, % (d_std / d_obs × 100)')
+
+
+                im4 = ax[3].plot(i_plot_cur,non_nan[i_plot_cur], 'k.', markersize=.5)
+                ax[3].set_ylabel('Number of data')
+                ax[3].set_xlim(xlim)
+
+                if cur_plType=='imshow':
+                    # Create an invisible colorbar for the last subplot
+                    cbar4 = fig.colorbar(im3, ax=ax[3])
+                    cbar4.solids.set(alpha=0)
+                    cbar4.outline.set_visible(False)
+                    cbar4.ax.set_yticks([])  # Hide the colorbar ticks
+                    cbar4.ax.set_yticklabels([])  # Hide the colorbar ticks labels
+
+                ax[-1].set_xlabel('Index')
+
+                ax[0].grid()
+                ax[1].grid()
+                ax[2].grid()
+                ax[3].grid()
+
+                if name_attr is not None:
+                    fig.suptitle("Dataset %s: %s" % (Dkey, name_attr))
                 else:
-                    im1 = ax[0].imshow(np.ma.masked_invalid(d_obs[i_plot,:]).T,
-                                       aspect='auto', cmap=_cmap_white_bad('jet_r'), extent=extent)
-                    im2 = ax[1].imshow(np.ma.masked_invalid(d_std[i_plot,:]).T,
-                                       aspect='auto', cmap=_cmap_white_bad('hot_r'), extent=extent)
-
-                # Relative noise in % — mask invalid entries
-                rel_noise = np.ma.masked_invalid(100.0 * d_std[i_plot,:] / d_obs[i_plot,:])
-                im3 = ax[2].imshow(rel_noise.T, aspect='auto', vmin=0, vmax=20,
-                                   cmap=_cmap_white_bad('turbo'), extent=extent)
-
-                fig.colorbar(im1, ax=ax[0])
-                fig.colorbar(im2, ax=ax[1])
-                fig.colorbar(im3, ax=ax[2])
-
-                ax[0].set_ylabel('gate number')
-                ax[1].set_ylabel('gate number')
-                ax[2].set_ylabel('gate number')
-
-                ax[0].set_title('d_obs: observed data')
-                ax[1].set_title('d_std: standard deviation')
-                ax[2].set_title('Relative noise, % (d_std / d_obs × 100)')
-
-
-            im4 = ax[3].plot(i_plot,non_nan[i_plot], 'k.', markersize=.5)
-            ax[3].set_ylabel('Number of data')
-            ax[3].set_xlim(xlim)
-
-            if plType=='imshow':
-                # Create an invisible colorbar for the last subplot
-                cbar4 = fig.colorbar(im3, ax=ax[3])
-                cbar4.solids.set(alpha=0)
-                cbar4.outline.set_visible(False)
-                cbar4.ax.set_yticks([])  # Hide the colorbar ticks
-                cbar4.ax.set_yticklabels([])  # Hide the colorbar ticks labels
-
-            ax[-1].set_xlabel('Index')
-
-            ax[0].grid()
-            ax[1].grid()
-            ax[2].grid()
-            ax[3].grid()
-
-            if name_attr is not None:
-                fig.suptitle("Dataset %s: %s" % (Dkey, name_attr))
-            else:
-                fig.suptitle("Dataset %s" % Dkey)
+                    fig.suptitle("Dataset %s" % Dkey)
 
-            plt.tight_layout()
-        else:
-            print("plot_data: Unknown noise model: %s" % noise_model)
+                plt.tight_layout()
 
-    # set plot in kwarg to True if not allready set
-    if 'hardcopy' not in kwargs:
-        kwargs['hardcopy'] = True
-    if kwargs['hardcopy']:
-        # strip the filename from f_data_h5
-        plt.savefig('%s_%s_%s.png' % (os.path.splitext(f_data_h5)[0],Dkey,plType), bbox_inches='tight')
+                if kwargs['hardcopy']:
+                    # strip the filename from f_data_h5
+                    plt.savefig('%s_%s_%s.png' % (os.path.splitext(f_data_h5)[0],Dkey,cur_plType), bbox_inches='tight')
+            else:
+                print("plot_data: Unknown noise model: %s" % noise_model)