pmagpy 4.3.3__py3-none-any.whl → 4.3.5__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,19 +209,37 @@ 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
 
 
@@ -858,7 +877,9 @@ def verwey_estimate(temps, mags,
     ax1.ticklabel_format(axis='y', style='scientific', scilimits=(0,0))
     if plot_title is not None:
         ax1.set_title(plot_title)
-    #plt.show()
+    
+    if plot_zero_crossing:
+        ax2 = zero_crossing(temps_dM_dT_background, mgt_dM_dT, make_plot=True)
 
     return verwey_estimate, remanence_loss
 
@@ -1821,7 +1842,8 @@ def MPMS_signal_blender_interactive(measurement_1, measurement_2,
         ax[1].set_title('RTSIRM cycling')
         ax[1].legend()
         ax[1].grid()
-        fig.canvas.draw()
+        # fig.canvas.draw()
+        fig.canvas.flush_events()
         plt.tight_layout()
     slider.observe(update, names='value')
     spec_1_dropdown.observe(update, names='value')
@@ -2128,7 +2150,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
 
@@ -2186,7 +2208,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
@@ -2251,11 +2273,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), 
@@ -3683,43 +3705,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]
@@ -3734,7 +3766,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"]
@@ -3744,26 +3776,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],
@@ -3773,6 +3806,22 @@ 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):
+                y_min = experiment[magnetization].min()
+                y_max = experiment[magnetization].max()
+                y_mid = y_min + 0.5 * (y_max - y_min)
+                p0.scatter(
+                    [-Bcr],
+                    [y_mid],
+                    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)
 
@@ -3782,11 +3831,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,
@@ -3801,6 +3850,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)
 
@@ -3812,12 +3864,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)
 
@@ -3828,7 +3883,7 @@ def plot_backfield_data(
             return grid
         return None
 
-    # static Matplotlib
+    # Static: Matplotlib
     panels = []
     if plot_raw:
         panels.append("raw")
@@ -3838,7 +3893,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]
 
@@ -3848,8 +3903,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"],
@@ -3867,16 +3940,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:
@@ -4197,7 +4272,8 @@ def interactive_backfield_fit(field, magnetization, n_components, skewed=True, f
         ax.set_xticklabels([f'{int(10**i)}' for i in ax.get_xticks()])
         ax.legend()
 
-        fig.canvas.draw()
+        # fig.canvas.draw()
+        fig.canvas.flush_events()
         if final_fit["df"] is None:
             final_fit["df"] = updated_parameters.copy()
         else:
@@ -4561,8 +4637,8 @@ def day_plot(Mr, Ms, Bcr, Bc,
     ax.set_yscale('log')
     ax.set_xticks([1, 2, 5, 10, 20, 50, 100], [1, 2, 5, 10, 20, 50, 100])
     ax.set_yticks([0.01, 0.02, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 1], [0.01, 0.02, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 1])
-    ax.set_xlabel('Bcr/Bc', fontsize=12)
-    ax.set_ylabel('Mr/Ms', fontsize=12)
+    ax.set_xlabel('B$_{cr}$/B$_{c}$', fontsize=12)
+    ax.set_ylabel('M$_{r}$/M$_{s}$', fontsize=12)
     ax.set_title('Day plot', fontsize=14)
 
     if legend:
@@ -4602,22 +4678,56 @@ def neel_plot_magic(specimen_data,
     ax : matplotlib.axes.Axes
         The axes object containing the plot.
     """
-    summary_sats = specimen_data.groupby(by).agg({Mr: 'mean', Ms: 'mean', Bcr: 'mean', Bc: 'mean'}).reset_index()
-    summary_sats = summary_sats.dropna()
+    summary_stats = specimen_data.groupby(by).agg({Mr: 'mean', Ms: 'mean', Bcr: 'mean', Bc: 'mean'}).reset_index()
+    summary_stats = summary_stats.dropna()
 
-    ax = neel_plot(Mr = summary_sats[Mr],
-                Ms = summary_sats[Ms],
-                Bc = summary_sats[Bc], 
+    ax = neel_plot(Mr = summary_stats[Mr],
+                Ms = summary_stats[Ms],
+                Bc = summary_stats[Bc], 
                 **kwargs)
     return ax
 
 
 def neel_plot(Mr, Ms, Bc, color='black', marker = 'o', label = 'sample', alpha=1, lc = 'black', lw=0.5, legend=True, axis_scale='linear', figsize = (5, 5)):
-    '''
-    fuction for making squareness coercivity plot
-        the original Neel diagram plots Mr/Ms vs Bc
-        a sister plot often used is Mr/M vs Bcr
-    '''
+    """
+    Generate a Néel plot (squareness-coercivity) of Mr/Ms versus Bc from hysteresis data.
+
+    This plot shows the ratio of remanent to saturation magnetization
+    (Mr/Ms) plotted against the coercivity (Bc). It is useful for 
+    characterizing magnetic domain states in rock magnetic samples.
+
+    Parameters
+    ----------
+    Mr : array-like
+        Saturation remanence values of the samples.
+    Ms : array-like
+        Saturation magnetization values of the samples.
+    Bc : array-like
+        Coercivity values of the samples.
+    color : str, optional
+        Color of the scatter points. Default is "black".
+    marker : str, optional
+        Marker style for scatter points. Default is "o".
+    label : str, optional
+        Label for the sample to be displayed in the legend. Default is "sample".
+    alpha : float, optional
+        Transparency of the scatter points. Default is 1 (opaque).
+    lc : str, optional
+        Color of the grid lines. Default is "black".
+    lw : float, optional
+        Line width of the grid lines. Default is 0.5.
+    legend : bool, optional
+        Whether to show the legend. Default is True.
+    axis_scale : str, optional
+        Scale for both axes: "linear" or "log". Default is "linear".
+    figsize : tuple of int, optional
+        Figure size in inches (width, height). Default is (5, 5).
+
+    Returns
+    -------
+    matplotlib.axes.Axes
+        The matplotlib axes object containing the plot.
+    """
     assert axis_scale in ['linear', 'log'], "axis_scale must be 'linear' or 'log'"
     # force numpy arrays
     Ms = np.asarray(Ms)
@@ -4626,8 +4736,8 @@ def neel_plot(Mr, Ms, Bc, color='black', marker = 'o', label = 'sample', alpha=1
     Mr_Ms = Mr/Ms
     _, ax = plt.subplots(figsize = figsize)
     ax.scatter(Bc, Mr_Ms, color = color, marker = marker, label = label, alpha=alpha, zorder = 100)
-    ax.set_xlabel('Bc', fontsize=12)
-    ax.set_ylabel('Mr/Ms', fontsize=12)
+    ax.set_xlabel('B$_c$ (T)', fontsize=12)
+    ax.set_ylabel('M$_r$/M$_s$', fontsize=12)
     if axis_scale == 'linear':
         ax.set_xscale('linear')   
         ax.set_yscale('linear')

pmagpy/version.py

@@ -3,5 +3,5 @@ Module contains current pmagpy version number.
 Version number is displayed by GUIs
 and used by setuptools to assign number to pmagpy/pmagpy-cli.
 """
-"pmagpy-4.3.3"
-version = 'pmagpy-4.3.3'
+"pmagpy-4.3.5"
+version = 'pmagpy-4.3.5'

{pmagpy-4.3.3.dist-info → pmagpy-4.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pmagpy
-Version: 4.3.3
+Version: 4.3.5
 Summary: Analysis tools for paleo/rock magnetic data
 Home-page: https://github.com/PmagPy/PmagPy
 Author: PmagPy team