pmagpy 4.3.4__py3-none-any.whl → 4.3.6__py3-none-any.whl

pmagpy/rockmag.py

@@ -94,6 +94,7 @@ def dict_in_native_python(d):
     """
     return {k: v.item() if isinstance(v, np.generic) else v for k, v in d.items()}
 
+
 def map_legend_location(matplotlib_loc):
     """
     Maps a Matplotlib legend location to a Bokeh legend location.
@@ -208,22 +209,68 @@ def interactive_specimen_experiment_selection(measurements):
     return specimen_dropdown, experiment_dropdown
 
 
-def make_experiment_df(measurements):
+def make_experiment_df(measurements, exclude_method_codes=None):
     """
     Creates a DataFrame of unique experiments from the measurements DataFrame.
 
-    Args:
-        measurements (pd.DataFrame): The DataFrame containing measurement data with columns 
-            'specimen', 'method_codes', and 'experiment'.
+    Parameters
+    ----------
+    measurements : pd.DataFrame
+        The DataFrame containing measurement data with columns 'specimen', 
+        'method_codes', and 'experiment'.
+    exclude_method_codes : list of str, optional
+        List of method codes to exclude from the output DataFrame. Rows with 
+        'method_codes' containing any of these substrings will be removed.
 
-    Returns:
-        pd.DataFrame: A DataFrame containing unique combinations of 'specimen', 'method_codes', 
-            and 'experiment'.
+    Returns
+    -------
+    pd.DataFrame
+        A DataFrame containing unique combinations of 'specimen', 'method_codes', 
+        and 'experiment'.
     """
-    experiments = measurements.groupby(['specimen', 'method_codes', 'experiment']).size().reset_index().iloc[:, :3]
+    if exclude_method_codes is not None:
+        mask = ~measurements["method_codes"].apply(
+            lambda x: any(code in x for code in exclude_method_codes)
+        )
+        measurements = measurements.loc[mask]
+
+    experiments = (
+        measurements.groupby(["specimen", "method_codes", "experiment"])
+        .size()
+        .reset_index()
+        .iloc[:, :3]
+    )
     return experiments
 
 
+def experiment_selection(measurements, experiment_name):
+    """
+    This function filters a measurements DataFrame to return only the rows 
+    that correspond to the specified experiment name. 
+    
+    Parameters
+    ----------
+    measurements : pd.DataFrame
+        The DataFrame containing measurement data with an 'experiment' column.
+    experiment_name : str
+        The name of the experiment to select from the DataFrame.
+    Returns
+    -------
+    pd.DataFrame
+        A DataFrame containing only the rows corresponding to the specified experiment.
+    """
+    if 'experiment' not in measurements.columns:
+        raise ValueError("The measurements DataFrame must contain an 'experiment' column.")
+    if not isinstance(experiment_name, str):
+        raise TypeError("The experiment_name must be a string.")
+    if experiment_name not in measurements['experiment'].unique():
+        raise ValueError(f"Experiment '{experiment_name}' not found in the measurements DataFrame.")
+    # Filter the DataFrame for the specified experiment
+    selected_experiment = measurements[measurements['experiment'] == experiment_name].reset_index(drop=True)
+    selected_experiment = clean_out_na(selected_experiment)
+    return selected_experiment
+
+
 def clean_out_na(dataframe):
     """
     Cleans a DataFrame by removing columns and rows that contain only NaN values.
@@ -931,7 +978,7 @@ def interactive_verwey_estimate(measurements, specimen_dropdown, method_dropdown
 
     display(ui)
 
-    fig, ax = plt.subplots(ncols=2, nrows=1, figsize=(12, 6))
+    fig, ax = plt.subplots(ncols=2, nrows=1, figsize=(10, 5))
     fig.canvas.header_visible = False
 
     def update_plot(*args):
@@ -2131,7 +2178,7 @@ def linefit(xarr, yarr):
     ss_res = np.sum((y_pred - np.mean(yarr))**2)
 
     # R^2 score
-    r2 = 1 - ss_res / ss_tot if ss_tot > 0 else 1
+    r2 = ss_res / ss_tot if ss_tot > 0 else 1
 
     return intercept, slope, r2
 
@@ -2189,7 +2236,7 @@ def loop_H_off(loop_fields, loop_moments, H_shift):
 def loop_Hshift_brent(loop_fields, loop_moments):
     def objective(H_shift):
         result = loop_H_off(loop_fields, loop_moments, H_shift)
-        return result['r2']
+        return -result['r2']
     
     ax = -np.max(loop_fields)/2
     bx = 0
@@ -2254,11 +2301,11 @@ def hyst_loop_centering(grid_field, grid_magnetization):
     M_sn, Q = calc_Q(grid_field, grid_magnetization)
 
     # re-gridding after offset correction to ensure symmetry
-    centered_H, centered_M = grid_hysteresis_loop(grid_field-H_offset/2, grid_magnetization-M_offset)
+    centered_H, centered_M = grid_hysteresis_loop(grid_field-H_offset, grid_magnetization-M_offset)
 
     results = {'centered_H':centered_H, 
                'centered_M': centered_M, 
-               'opt_H_offset':float(H_offset/2), 
+               'opt_H_offset':float(H_offset), 
                'opt_M_offset':float(M_offset), 
                'R_squared':float(R_squared), 
                'M_sn':float(M_sn), 
@@ -3198,212 +3245,248 @@ def plot_X_T(
     remove_holder=True,
     plot_derivative=True,
     plot_inverse=False,
+    interactive=True,
     return_figure=False,
-    panel_height=400,
+    figsize=(6, 6),
 ):
     """
     Plot the high-temperature susceptibility curve, and optionally its derivative
-    and reciprocal using Bokeh.
+    and reciprocal using Bokeh or Matplotlib.
 
     Parameters:
-        experiment (pandas.DataFrame):
-            The IRM experiment data exported into MagIC format.
-        temperature_column (str, optional):
-            Name of the temperature column. Defaults to "meas_temp".
-        magnetic_column (str, optional):
-            Name of the susceptibility column. Defaults to "susc_chi_mass".
-        temp_unit (str, optional):
-            Unit of temperature, either "K" or "C". Defaults to "C".
-        smooth_window (int, optional):
-            Window size for running-average smoothing. Defaults to 0.
-        remove_holder (bool, optional):
-            If True, subtract the minimum holder signal. Defaults to True.
-        plot_derivative (bool, optional):
-            If True, generate dk/dT plot. Defaults to True.
-        plot_inverse (bool, optional):
-            If True, generate 1/k plot. Defaults to False.
-        return_figure (bool, optional):
-            If True, return the Bokeh figure objects. Defaults to False.
-
-    Returns:
-        tuple[bokeh.plotting.figure.Figure, ...] or None:
-            The requested Bokeh figures if return_figure is True;
-            otherwise, None.
+        experiment (pandas.DataFrame): MagIC-formatted experiment DataFrame.
+        temperature_column (str): Name of temperature column.
+        magnetic_column (str): Name of susceptibility column.
+        temp_unit (str): "C" for Celsius.
+        smooth_window (int): Window for smoothing.
+        remove_holder (bool): Subtract holder signal.
+        plot_derivative (bool): Plot derivative.
+        plot_inverse (bool): Plot inverse.
+        interactive (bool): True for Bokeh, False for Matplotlib.
+        return_figure (bool): Return figure objects if True.
+        figsize (tuple): (width, height) in inches.
     """
     warm_T, warm_X, cool_T, cool_X = split_warm_cool(
         experiment,
         temperature_column=temperature_column,
         magnetic_column=magnetic_column,
     )
-
     if temp_unit == "C":
         warm_T = [T - 273.15 for T in warm_T]
         cool_T = [T - 273.15 for T in cool_T]
     else:
-        raise ValueError('temp_unit must be either "K" or "C"')
-
+        raise ValueError('temp_unit must be "C"')
     if remove_holder:
         holder_w = min(warm_X)
         holder_c = min(cool_X)
         warm_X = [X - holder_w for X in warm_X]
         cool_X = [X - holder_c for X in cool_X]
-
     swT, swX = smooth_moving_avg(warm_T, warm_X, smooth_window)
     scT, scX = smooth_moving_avg(cool_T, cool_X, smooth_window)
-
     title = experiment["specimen"].unique()[0]
+    figs = []
 
-    p = figure(
-        title=title,
-        sizing_mode="stretch_width",
-        height=panel_height,
-        x_axis_label=f"Temperature (°{temp_unit})",
-        y_axis_label="k (m³ kg⁻¹)",
-        tools="pan,wheel_zoom,box_zoom,reset,save",
-    )
-    p.xaxis.axis_label_text_font_style = "normal"
-    p.yaxis.axis_label_text_font_style = "normal"
-
-    r_warm_c = p.scatter(
-        warm_T, warm_X, legend_label="Heating",
-        color="red", alpha=0.5, size=6,
-    )
-    r_warm_l = p.line(
-        swT, swX, legend_label="Heating – smoothed",
-        line_width=2, color="red",
-    )
-
-    r_cool_c = p.scatter(
-        cool_T, cool_X, legend_label="Cooling",
-        color="blue", alpha=0.5, size=6,
-    )
-    r_cool_l = p.line(
-        scT, scX, legend_label="Cooling – smoothed",
-        line_width=2, color="blue",
-    )
-
-    p.add_tools(
-        HoverTool(renderers=[r_warm_c, r_warm_l],
-                  tooltips=[("T", "@x"), ("Heating k", "@y")])
-    )
-    p.add_tools(
-        HoverTool(renderers=[r_cool_c, r_cool_l],
-                  tooltips=[("T", "@x"), ("Cooling k", "@y")])
-    )
-
-    p.grid.grid_line_color = "lightgray"
-    p.outline_line_color = "black"
-    p.background_fill_color = "white"
-    p.legend.location = "top_left"
-
-    figs = [p]
-
-    if plot_derivative:
-        p_dx = figure(
-            title=f"{title} – dk/dT",
+    if interactive:
+        bokeh_height = int(figsize[1] * 96)
+        # Main plot
+        p = figure(
+            title=title,
             sizing_mode="stretch_width",
-            height=panel_height,
+            height=bokeh_height,
             x_axis_label=f"Temperature (°{temp_unit})",
-            y_axis_label="dk/dT",
+            y_axis_label="χ (m³ kg⁻¹)",
             tools="pan,wheel_zoom,box_zoom,reset,save",
         )
-        p_dx.xaxis.axis_label_text_font_style = "normal"
-        p_dx.yaxis.axis_label_text_font_style = "normal"
-        dx_w = np.gradient(swX, swT)
-        dx_c = np.gradient(scX, scT)
-        r_dx_w = p_dx.line(
-            swT, dx_w, legend_label="Heating – dk/dT",
-            line_width=2, color="red"
-        )
-        r_dx_w_c = p_dx.scatter(
-            swT, dx_w, legend_label="Heating – dk/dT",
-            color="red", alpha=0.5, size=6
-        )
-        r_dx_c = p_dx.line(
-            scT, dx_c, legend_label="Cooling – dk/dT",
-            line_width=2, color="blue"
-        )
-        r_dx_c_c = p_dx.scatter(
-            scT, dx_c, legend_label="Cooling – dk/dT",
-            color="blue", alpha=0.5, size=6
-        )
-        p_dx.add_tools(
-            HoverTool(renderers=[r_dx_w],
-                      tooltips=[("T", "@x"), ("dk/dT (heat)", "@y")])
-        )
-        p_dx.add_tools(
-            HoverTool(renderers=[r_dx_c],
-                      tooltips=[("T", "@x"), ("dk/dT (cool)", "@y")])
-        )
-        p_dx.grid.grid_line_color = "lightgray"
-        p_dx.outline_line_color = "black"
-        p_dx.background_fill_color = "white"
-        p_dx.legend.location = "top_left"
-        p_dx.legend.click_policy = "hide"
-        figs.append(p_dx)
-
-    if plot_inverse:
-        p_inv = figure(
-            title=f"{title} – 1/k",
-            sizing_mode="stretch_width",
-            height=panel_height,
-            x_axis_label=f"Temperature (°{temp_unit})",
-            y_axis_label="1/k",
-            tools="pan,wheel_zoom,box_zoom,reset,save",
+        p.xaxis.axis_label_text_font_style = "normal"
+        p.yaxis.axis_label_text_font_style = "normal"
+        r_warm_c = p.scatter(
+            warm_T, warm_X, legend_label="Heating",
+            color="red", alpha=0.5, size=6,
         )
-        p_inv.xaxis.axis_label_text_font_style = "normal"
-        p_inv.yaxis.axis_label_text_font_style = "normal"
-        # compute inverse safely (zeros become NaN)
-        swX_arr = np.array(swX)
-        scX_arr = np.array(scX)
-        inv_w = np.divide(1.0, swX_arr, out=np.full_like(swX_arr, np.nan), where=swX_arr != 0.0)
-        inv_c = np.divide(1.0, scX_arr, out=np.full_like(scX_arr, np.nan), where=scX_arr != 0.0)
-
-        # mask to finite values only
-        mask_w = np.isfinite(inv_w)
-        mask_c = np.isfinite(inv_c)
-
-        # plot heating inverse
-        r_inv_w = p_inv.line(
-            np.array(swT)[mask_w],
-            inv_w[mask_w],
-            legend_label="Heating – 1/k",
+        r_warm_l = p.line(
+            swT, swX, legend_label="Heating",
             line_width=2, color="red",
         )
-        r_inv_w_c = p_inv.scatter(
-            np.array(swT)[mask_w],
-            inv_w[mask_w],
-            color="red", alpha=0.5, size=6
+        r_cool_c = p.scatter(
+            cool_T, cool_X, legend_label="Cooling",
+            color="blue", alpha=0.5, size=6,
         )
-        # plot cooling inverse
-        r_inv_c = p_inv.line(
-            np.array(scT)[mask_c],
-            inv_c[mask_c],
-            legend_label="Cooling – 1/k",
+        r_cool_l = p.line(
+            scT, scX, legend_label="Cooling",
             line_width=2, color="blue",
         )
-        r_inv_c_c = p_inv.scatter(
-            np.array(scT)[mask_c],
-            inv_c[mask_c],
-            color="blue", alpha=0.5, size=6
+        p.add_tools(
+            HoverTool(renderers=[r_warm_c, r_warm_l],
+                      tooltips=[("T", "@x"), ("Heating χ", "@y")])
         )
-        p_inv.add_tools(
-            HoverTool(renderers=[r_inv_w],
-                      tooltips=[("T", "@x"), ("1/k (heat)", "@y")])
+        p.add_tools(
+            HoverTool(renderers=[r_cool_c, r_cool_l],
+                      tooltips=[("T", "@x"), ("Cooling χ", "@y")])
         )
-        p_inv.add_tools(
-            HoverTool(renderers=[r_inv_c],
-                      tooltips=[("T", "@x"), ("1/k (cool)", "@y")])
-        )
-        p_inv.grid.grid_line_color = "lightgray"
-        p_inv.outline_line_color = "black"
-        p_inv.background_fill_color = "white"
-        p_inv.legend.location = "top_left"
-        p_inv.legend.click_policy = "hide"
-        figs.append(p_inv)
+        p.grid.grid_line_color = "lightgray"
+        p.outline_line_color = "black"
+        p.background_fill_color = "white"
+        p.legend.location = "top_left"
+        p.legend.click_policy = "hide"
+        figs.append(p)
 
-    for fig in figs:
-        show(fig)
+        # Derivative
+        if plot_derivative:
+            p_dx = figure(
+                title=f"{title} – dχ/dT",
+                sizing_mode="stretch_width",
+                height=bokeh_height,
+                x_axis_label=f"Temperature (°{temp_unit})",
+                y_axis_label="dχ/dT",
+                tools="pan,wheel_zoom,box_zoom,reset,save",
+            )
+            p_dx.xaxis.axis_label_text_font_style = "normal"
+            p_dx.yaxis.axis_label_text_font_style = "normal"
+            dx_w = np.gradient(swX, swT)
+            dx_c = np.gradient(scX, scT)
+            r_dx_w = p_dx.line(
+                swT, dx_w, legend_label="Heating – dχ/dT",
+                line_width=2, color="red"
+            )
+            r_dx_w_c = p_dx.scatter(
+                swT, dx_w, legend_label="Heating – dχ/dT",
+                color="red", alpha=0.5, size=6
+            )
+            r_dx_c = p_dx.line(
+                scT, dx_c, legend_label="Cooling – dχ/dT",
+                line_width=2, color="blue"
+            )
+            r_dx_c_c = p_dx.scatter(
+                scT, dx_c, legend_label="Cooling – dχ/dT",
+                color="blue", alpha=0.5, size=6
+            )
+            p_dx.add_tools(
+                HoverTool(renderers=[r_dx_w, r_dx_w_c],
+                          tooltips=[("T", "@x"), ("dχ/dT (heat)", "@y")])
+            )
+            p_dx.add_tools(
+                HoverTool(renderers=[r_dx_c, r_dx_c_c],
+                          tooltips=[("T", "@x"), ("dχ/dT (cool)", "@y")])
+            )
+            p_dx.grid.grid_line_color = "lightgray"
+            p_dx.outline_line_color = "black"
+            p_dx.background_fill_color = "white"
+            p_dx.legend.location = "top_left"
+            p_dx.legend.click_policy = "hide"
+            figs.append(p_dx)
+
+        # Inverse
+        if plot_inverse:
+            p_inv = figure(
+                title=f"{title} – 1/χ",
+                sizing_mode="stretch_width",
+                height=bokeh_height,
+                x_axis_label=f"Temperature (°{temp_unit})",
+                y_axis_label="1/χ",
+                tools="pan,wheel_zoom,box_zoom,reset,save",
+            )
+            p_inv.xaxis.axis_label_text_font_style = "normal"
+            p_inv.yaxis.axis_label_text_font_style = "normal"
+            swX_arr = np.array(swX)
+            scX_arr = np.array(scX)
+            inv_w = np.divide(1.0, swX_arr,
+                              out=np.full_like(swX_arr, np.nan),
+                              where=swX_arr != 0.0)
+            inv_c = np.divide(1.0, scX_arr,
+                              out=np.full_like(scX_arr, np.nan),
+                              where=scX_arr != 0.0)
+            mask_w = np.isfinite(inv_w)
+            mask_c = np.isfinite(inv_c)
+            r_inv_w = p_inv.line(
+                np.array(swT)[mask_w], inv_w[mask_w],
+                legend_label="Heating – 1/χ",
+                line_width=2, color="red",
+            )
+            r_inv_w_c = p_inv.scatter(
+                np.array(swT)[mask_w], inv_w[mask_w],
+                color="red", alpha=0.5, size=6
+            )
+            r_inv_c = p_inv.line(
+                np.array(scT)[mask_c], inv_c[mask_c],
+                legend_label="Cooling – 1/χ",
+                line_width=2, color="blue",
+            )
+            r_inv_c_c = p_inv.scatter(
+                np.array(scT)[mask_c], inv_c[mask_c],
+                color="blue", alpha=0.5, size=6
+            )
+            p_inv.add_tools(
+                HoverTool(renderers=[r_inv_w, r_inv_w_c],
+                          tooltips=[("T", "@x"), ("1/χ (heat)", "@y")])
+            )
+            p_inv.add_tools(
+                HoverTool(renderers=[r_inv_c, r_inv_c_c],
+                          tooltips=[("T", "@x"), ("1/χ (cool)", "@y")])
+            )
+            p_inv.grid.grid_line_color = "lightgray"
+            p_inv.outline_line_color = "black"
+            p_inv.background_fill_color = "white"
+            p_inv.legend.location = "top_left"
+            p_inv.legend.click_policy = "hide"
+            figs.append(p_inv)
+
+        for fig in figs:
+            show(fig)
+
+    else:
+        fig_kwargs = {"figsize": figsize}
+        fig1, ax1 = plt.subplots(**fig_kwargs)
+        ax1.scatter(warm_T, warm_X, label="Heating", alpha=0.5)
+        ax1.plot(swT, swX, label="Heating – smoothed", linewidth=2)
+        ax1.scatter(cool_T, cool_X, label="Cooling", alpha=0.5)
+        ax1.plot(scT, scX, label="Cooling – smoothed", linewidth=2)
+        ax1.set_title(title)
+        ax1.set_xlabel(f"Temperature (°{temp_unit})")
+        ax1.set_ylabel("χ (m³ kg⁻¹)")
+        ax1.grid(True)
+        ax1.legend(loc="upper left")
+        figs.append(fig1)
+
+        if plot_derivative:
+            dx_w = np.gradient(swX, swT)
+            dx_c = np.gradient(scX, scT)
+            fig2, ax2 = plt.subplots(**fig_kwargs)
+            ax2.plot(swT, dx_w, label="Heating – dχ/dT", linewidth=2, marker="o")
+            ax2.plot(scT, dx_c, label="Cooling – dχ/dT", linewidth=2, marker="o")
+            ax2.set_title(f"{title} – dχ/dT")
+            ax2.set_xlabel(f"Temperature (°{temp_unit})")
+            ax2.set_ylabel("dχ/dT")
+            ax2.grid(True)
+            ax2.legend(loc="upper left")
+            figs.append(fig2)
+
+        if plot_inverse:
+            swX_arr = np.array(swX)
+            scX_arr = np.array(scX)
+            inv_w = np.divide(
+                1.0, swX_arr,
+                out=np.full_like(swX_arr, np.nan),
+                where=swX_arr != 0.0,
+            )
+            inv_c = np.divide(
+                1.0, scX_arr,
+                out=np.full_like(scX_arr, np.nan),
+                where=scX_arr != 0.0,
+            )
+            mask_w = np.isfinite(inv_w)
+            mask_c = np.isfinite(inv_c)
+            fig3, ax3 = plt.subplots(**fig_kwargs)
+            ax3.plot(np.array(swT)[mask_w], inv_w[mask_w], label="Heating – 1/χ", linewidth=2, marker="o")
+            ax3.plot(np.array(scT)[mask_c], inv_c[mask_c], label="Cooling – 1/χ", linewidth=2, marker="o")
+            ax3.set_title(f"{title} – 1/χ")
+            ax3.set_xlabel(f"Temperature (°{temp_unit})")
+            ax3.set_ylabel("1/χ")
+            ax3.grid(True)
+            ax3.legend(loc="upper left")
+            figs.append(fig3)
+
+        for fig in figs:
+            plt.show(fig)
 
     if return_figure:
         return tuple(figs)
@@ -3686,43 +3769,53 @@ def backfield_data_processing(experiment, field='treat_dc_field', magnetization=
         experiment['smoothed_log_dc_field'] = spl[:, 0]
     return experiment, Bcr
     
+    
 def plot_backfield_data(
     experiment,
     field="treat_dc_field",
     magnetization="magn_mass",
-    figsize=(5, 12),
+    Bcr=None,
+    size=(5, 10),
     plot_raw=True,
     plot_processed=True,
     plot_spectrum=True,
     interactive=False,
-    return_figure=True,
+    return_figure=False,
     show_plot=True,
+    y_axis_units="Am²/kg",
+    legend_location="upper left"
 ):
     """
     Plot backfield data: raw, processed, and coercivity spectrum.
 
-    Data processing steps:
-      - Raw: magnetization vs. field (T).
-      - Processed: magn_mass_shift = magn_mass − min(magn_mass);
-        log_dc_field = log10(−field·1e3) (log10 mT axis).
-      - Spectrum: derivative −ΔM/Δ(log B).
-
     Parameters
     ----------
     experiment : DataFrame
         Must contain raw and, if requested, processed columns.
+    field : str
+        Name of the magnetic field column.
+    magnetization : str
+        Name of the magnetization column.
+    Bcr : float, optional
+        Calculated Bcr (T). If provided, will be plotted as a pink star.
+    size : tuple(float, float)
+        Figure size (in inches).
     plot_raw : bool
     plot_processed : bool
     plot_spectrum : bool
     interactive : bool
     return_figure : bool
     show_plot : bool
+    y_axis_units : str, optional
+        Units to display on the y-axis labels of raw and processed panels.
+    legend_location : str, optional
+        Location of the legend in Matplotlib terms.
 
     Returns
     -------
     Matplotlib (fig, axes) or Bokeh grid or None
     """
-    # check columns
+    # Check columns
     req = []
     if plot_raw:
         req += [field, magnetization]
@@ -3737,7 +3830,7 @@ def plot_backfield_data(
     if missing:
         raise KeyError(f"Missing columns: {missing}")
 
-    # prepare spectrum
+    # Prepare spectrum
     if plot_spectrum:
         log_b = experiment["log_dc_field"]
         shift_m = experiment["magn_mass_shift"]
@@ -3747,26 +3840,27 @@ def plot_backfield_data(
             experiment["smoothed_log_dc_field"]
         )
         smooth_dx_log = experiment["smoothed_log_dc_field"].rolling(2).mean().dropna()
-        # axis: convert log10(mT) → mT for plotting, but axis scale remains log
-        raw_dx = 10**raw_dx_log
-        smooth_dx = 10**smooth_dx_log
+        raw_dx = 10 ** raw_dx_log
+        smooth_dx = 10 ** smooth_dx_log
 
-    if interactive:
+    # Interactive: Bokeh
+    if interactive and _HAS_BOKEH:
         tools = [
             HoverTool(tooltips=[("Field (T)", "@x"), ("Mag", "@y")]),
             "pan,box_zoom,wheel_zoom,reset,save"
         ]
         figs = []
-        palette = Category10[3]
+        palette = Category10[4]
+        bokeh_height = int(size[1]/3 * 96)
 
         if plot_raw:
             p0 = figure(
                 title="Raw backfield",
                 x_axis_label="Field (T)",
-                y_axis_label="Magnetization",
+                y_axis_label=f"Magnetization ({y_axis_units})",
                 tools=tools,
                 sizing_mode="stretch_width",
-                height = figsize[1]*25,
+                height=bokeh_height,
             )
             p0.scatter(
                 experiment[field],
@@ -3776,6 +3870,19 @@ def plot_backfield_data(
                 size=6,
             )
             p0.line(experiment[field], experiment[magnetization], color=palette[0])
+            if Bcr is not None and not np.isnan(Bcr):
+                p0.scatter(
+                    [-Bcr],
+                    0,
+                    size=15,
+                    color="pink",
+                    marker="star",
+                    line_color="black",
+                    legend_label=f"Bcr = {Bcr:.5f} T",
+                )
+            p0.xaxis.axis_label_text_font_style = "normal"
+            p0.yaxis.axis_label_text_font_style = "normal"
+            p0.legend.location = map_legend_location(legend_location)
             p0.legend.click_policy = "hide"
             figs.append(p0)
 
@@ -3785,11 +3892,11 @@ def plot_backfield_data(
             p1 = figure(
                 title="Processed backfield",
                 x_axis_label="Field (mT)",
-                y_axis_label="Magnetization",
+                y_axis_label=f"Magnetization ({y_axis_units})",
                 x_axis_type="log",
                 tools=tools,
                 sizing_mode="stretch_width",
-                height = figsize[1]*25,
+                height=bokeh_height,
             )
             p1.scatter(
                 x_shifted,
@@ -3804,6 +3911,9 @@ def plot_backfield_data(
                 color=palette[1],
                 legend_label="smoothed",
             )
+            p1.xaxis.axis_label_text_font_style = "normal"
+            p1.yaxis.axis_label_text_font_style = "normal"
+            p1.legend.location = map_legend_location(legend_location)
             p1.legend.click_policy = "hide"
             figs.append(p1)
 
@@ -3815,12 +3925,15 @@ def plot_backfield_data(
                 x_axis_type="log",
                 tools=tools,
                 sizing_mode="stretch_width",
-                height = figsize[1]*25,
+                height=bokeh_height,
             )
             p2.scatter(raw_dx, raw_dy, legend_label="raw spectrum",
                        color=palette[2], size=6)
             p2.line(smooth_dx, smooth_dy, color=palette[2],
                     legend_label="smoothed spectrum")
+            p2.xaxis.axis_label_text_font_style = "normal"
+            p2.yaxis.axis_label_text_font_style = "normal"
+            p2.legend.location = map_legend_location(legend_location)
             p2.legend.click_policy = "hide"
             figs.append(p2)
 
@@ -3831,7 +3944,7 @@ def plot_backfield_data(
             return grid
         return None
 
-    # static Matplotlib
+    # Static: Matplotlib
     panels = []
     if plot_raw:
         panels.append("raw")
@@ -3841,7 +3954,7 @@ def plot_backfield_data(
         panels.append("spectrum")
 
     n = len(panels)
-    fig, axes = plt.subplots(nrows=n, ncols=1, figsize=figsize)
+    fig, axes = plt.subplots(nrows=n, ncols=1, figsize=size)
     if n == 1:
         axes = [axes]
 
@@ -3851,8 +3964,26 @@ def plot_backfield_data(
                 experiment[field], experiment[magnetization], c="k", s=10, label="raw"
             )
             ax.plot(experiment[field], experiment[magnetization], c="k")
-            ax.set(title="raw backfield", xlabel="field (T)", ylabel="magnetization")
-            ax.legend()
+            if Bcr is not None and not np.isnan(Bcr):
+                y_min = experiment[magnetization].min()
+                y_max = experiment[magnetization].max()
+                y_mid = y_min + 0.5 * (y_max - y_min)
+                ax.scatter(
+                    -Bcr,
+                    y_mid,
+                    marker="*",
+                    s=150,
+                    c="pink",
+                    edgecolors="black",
+                    label=f"Bcr = {Bcr:.5f} T",
+                    zorder=10,
+                )
+            ax.set(
+                title="raw backfield",
+                xlabel="field (T)",
+                ylabel=f"magnetization ({y_axis_units})",
+            )
+            ax.legend(loc=legend_location)
         elif panel == "processed":
             ax.scatter(
                 experiment["log_dc_field"],
@@ -3870,16 +4001,18 @@ def plot_backfield_data(
             ticks = ax.get_xticks()
             ax.set_xticklabels([f"{round(10**t, 1)}" for t in ticks])
             ax.set(
-                title="processed", xlabel="field (mT)", ylabel="magnetization"
+                title="processed",
+                xlabel="field (mT)",
+                ylabel=f"magnetization ({y_axis_units})",
             )
-            ax.legend()
+            ax.legend(loc=legend_location)
         else:  # spectrum
             ax.scatter(raw_dx_log, raw_dy, c="gray", s=10, label="raw spectrum")
             ax.plot(smooth_dx_log, smooth_dy, c="k", label="smoothed spectrum")
             ticks = ax.get_xticks()
             ax.set_xticklabels([f"{round(10**t, 1)}" for t in ticks])
             ax.set(title="spectrum", xlabel="field (mT)", ylabel="dM/dB")
-            ax.legend()
+            ax.legend(loc=legend_location)
 
     fig.tight_layout()
     if show_plot:
@@ -4721,6 +4854,7 @@ def Langevin(alpha):
     '''
     return 1 / np.tanh(alpha) - 1 / alpha
 
+
 def magnetite_Ms(T):
     '''
     Magnetite saturation magnetization calculation
@@ -4737,6 +4871,7 @@ def magnetite_Ms(T):
     '''
     return 737.384 * 51.876 * (580 - T)**0.4
 
+
 def chi_SP(SP_size, T):
     '''
     SP size distribution function
@@ -4790,6 +4925,7 @@ def SP_SD_mixture(SP_size, SD_Mr_Ms = 0.5, SD_Bcr_Bc = 1.25, X_sd = 3, T = 300):
 
     return Bcr_Bc, Mrs_Ms
 
+
 def SP_saturation_curve(SD_Mr_Ms=0.5, SD_Bcr_Bc = 1.25):
     '''
     function to calculate the SP saturation curve according to Dunlop (2002)
@@ -4813,6 +4949,7 @@ def SP_saturation_curve(SD_Mr_Ms=0.5, SD_Bcr_Bc = 1.25):
     Bcr_Bc = 1 / (1 - (f_sp/f_sd) / SD_Mr_Ms) * SD_Bcr_Bc
     return Bcr_Bc, Mrs_Ms
 
+
 def SD_MD_mixture(Mr_Ms_SD = 0.5, Mr_Ms_MD = 0.019,
                   Bc_SD = 400, Bc_MD = 43,
                   Bcr_SD = 500, Bcr_MD = 230,