batplot 1.8.4__py3-none-any.whl → 1.8.6__py3-none-any.whl

batplot/modes.py

@@ -151,7 +151,8 @@ def handle_cv_mode(args) -> int:
         # Configure fonts to match other modes (consistent across batplot)
         plt.rcParams.update({
             'font.family': 'sans-serif',
-            'font.sans-serif': ['Arial', 'DejaVu Sans', 'Helvetica', 'STIXGeneral', 'Liberation Sans', 'Arial Unicode MS'],
+            # Prefer DejaVu Sans first for full Unicode coverage (subscripts, etc.)
+            'font.sans-serif': ['DejaVu Sans', 'Arial', 'Helvetica', 'STIXGeneral', 'Liberation Sans', 'Arial Unicode MS'],
             'mathtext.fontset': 'dejavusans',
             'font.size': 16
         })
@@ -280,8 +281,8 @@ def handle_cv_mode(args) -> int:
             ax.set_xlabel('Current (mA)', labelpad=8.0)
             ax.set_ylabel('Voltage (V)', labelpad=8.0)
         else:
-        ax.set_xlabel('Voltage (V)', labelpad=8.0)
-        ax.set_ylabel('Current (mA)', labelpad=8.0)
+            ax.set_xlabel('Voltage (V)', labelpad=8.0)
+            ax.set_ylabel('Current (mA)', labelpad=8.0)
         legend = ax.legend(title='Cycle')
         legend.get_title().set_fontsize('medium')
         # Adjust margins to prevent label clipping
@@ -642,8 +643,8 @@ def handle_gc_mode(args) -> int:
                         ln_c, = ax.plot(y_b, x_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
                                         linewidth=2.0, label=str(cyc), alpha=0.8)
                     else:
-                    ln_c, = ax.plot(x_b, y_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
-                                    linewidth=2.0, label=str(cyc), alpha=0.8)
+                        ln_c, = ax.plot(x_b, y_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
+                                        linewidth=2.0, label=str(cyc), alpha=0.8)
                 else:
                     ln_c = None
                 mask_d = (cyc_int == cyc) & discharge_mask
@@ -656,8 +657,8 @@ def handle_gc_mode(args) -> int:
                         ln_d, = ax.plot(yd_b, xd_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
                                         linewidth=2.0, label=lbl, alpha=0.8)
                     else:
-                    ln_d, = ax.plot(xd_b, yd_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
-                                    linewidth=2.0, label=lbl, alpha=0.8)
+                        ln_d, = ax.plot(xd_b, yd_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
+                                        linewidth=2.0, label=lbl, alpha=0.8)
                 else:
                     ln_d = None
                 cycle_lines[cyc] = {"charge": ln_c, "discharge": ln_d}
@@ -690,8 +691,8 @@ def handle_gc_mode(args) -> int:
                         ln_d, = ax.plot(yd_b, xd_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
                                         linewidth=2.0, label=lbl, alpha=0.8)
                     else:
-                    ln_d, = ax.plot(xd_b, yd_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
-                                    linewidth=2.0, label=lbl, alpha=0.8)
+                        ln_d, = ax.plot(xd_b, yd_b, '-', color=base_colors[(cyc-1) % len(base_colors)],
+                                        linewidth=2.0, label=lbl, alpha=0.8)
                 cycle_lines[cyc] = {"charge": ln_c, "discharge": ln_d}
                 
         # Swap x and y if --ro flag is set
@@ -699,8 +700,8 @@ def handle_gc_mode(args) -> int:
             ax.set_xlabel('Voltage (V)', labelpad=8.0)
             ax.set_ylabel(x_label_gc, labelpad=8.0)
         else:
-        ax.set_xlabel(x_label_gc, labelpad=8.0)
-        ax.set_ylabel('Voltage (V)', labelpad=8.0)
+            ax.set_xlabel(x_label_gc, labelpad=8.0)
+            ax.set_ylabel('Voltage (V)', labelpad=8.0)
         legend = ax.legend(title='Cycle')
         legend.get_title().set_fontsize('medium')
         fig.subplots_adjust(left=0.12, right=0.95, top=0.88, bottom=0.15)

batplot/operando.py

@@ -296,6 +296,28 @@ def plot_operando_folder(folder: str, args) -> Tuple[plt.Figure, plt.Axes, Dict[
     # Result shape: (n_scans, n_x_points)
     # Example: 50 scans × 1000 points = (50, 1000) array
     Z = np.vstack(stack)  # shape (n_scans, n_x)
+    
+    # STEP 5.5: Apply first derivative if --1d or --2d flag is set
+    # This calculates dy/dx for each scan using np.gradient
+    if getattr(args, 'derivative_1d', False) or getattr(args, 'derivative_2d', False):
+        print("[operando] Applying first derivative (dy/dx) to each scan...")
+        Z_deriv = np.zeros_like(Z)
+        for i in range(Z.shape[0]):
+            row = Z[i, :]
+            # Calculate derivative using gradient (handles NaN gracefully in numpy 1.20+)
+            # Use the grid spacing for proper derivative calculation
+            dx = grid_x[1] - grid_x[0] if len(grid_x) > 1 else 1.0
+            # Replace NaN with interpolated values for gradient, then mask back
+            valid_mask = ~np.isnan(row)
+            if np.sum(valid_mask) > 1:
+                # For valid regions, calculate gradient
+                deriv = np.gradient(row, dx)
+                # Keep NaN where original was NaN
+                deriv[~valid_mask] = np.nan
+                Z_deriv[i, :] = deriv
+            else:
+                Z_deriv[i, :] = np.nan
+        Z = Z_deriv
 
     # Detect an electrochemistry .mpt file in the same folder (if any)
     # Filter out macOS resource fork files (starting with ._)

batplot/operando_ec_interactive.py

@@ -832,7 +832,8 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                 "ox: X range",
                 "oy: Y range",
                 "oz: intensity range",
-                "or: rename"
+                "or: rename",
+                "pk: peak search"
             ]
             col3 = [
                 "et: time range",
@@ -849,6 +850,17 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                 "b: undo",
                 "q: quit",
             ]
+            # Conditional overwrite shortcuts under (Options)
+            last_session = getattr(fig, "_last_session_save_path", None)
+            last_style = getattr(fig, "_last_style_export_path", None)
+            last_figure = getattr(fig, "_last_figure_export_path", None)
+            if last_session:
+                col4.append("os: overwrite session")
+            if last_style:
+                col4.append("ops: overwrite style")
+                col4.append("opsg: overwrite style+geom")
+            if last_figure:
+                col4.append("oe: overwrite figure")
             # Dynamic column widths
             w1 = max(len("(Styles)"), *(len(s) for s in col1), 12)
             w2 = max(len("(Operando)"), *(len(s) for s in col2), 14)
@@ -885,7 +897,8 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                 "ox: X range",
                 "oy: Y range",
                 "oz: intensity range",
-                "or: rename"
+                "or: rename",
+                "pk: peak search"
             ]
             col3 = [
                 "n: crosshair",
@@ -896,6 +909,17 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                 "b: undo",
                 "q: quit",
             ]
+            # Conditional overwrite shortcuts under (Options)
+            last_session = getattr(fig, "_last_session_save_path", None)
+            last_style = getattr(fig, "_last_style_export_path", None)
+            last_figure = getattr(fig, "_last_figure_export_path", None)
+            if last_session:
+                col3.append("os: overwrite session")
+            if last_style:
+                col3.append("ops: overwrite style")
+                col3.append("opsg: overwrite style+geom")
+            if last_figure:
+                col3.append("oe: overwrite figure")
             w1 = max(len("(Styles)"), *(len(s) for s in col1), 12)
             w2 = max(len("(Operando)"), *(len(s) for s in col2), 14)
             w3 = max(len("(Options)"), *(len(s) for s in col3), 16)
@@ -1220,6 +1244,9 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
             }
             # EC WASD state (only if ec_ax exists)
             if ec_ax is not None:
+                # For EC, check if ylabel is currently visible (not hidden by user via d5)
+                # EC uses the actual ylabel positioned on right, not a duplicate artist
+                ec_ylabel_visible = bool(ec_ax.get_ylabel())  # Empty string = hidden
                 ec_wasd = {
                     'top':    {'spine': _get_spine_visible(ec_ax, 'top'), 'ticks': ec_ax.xaxis._major_tick_kw.get('tick1On', True), 
                                'minor': bool(ec_ax.xaxis._minor_tick_kw.get('tick1On', False)), 
@@ -1232,11 +1259,11 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                     'left':   {'spine': _get_spine_visible(ec_ax, 'left'), 'ticks': ec_ax.yaxis._major_tick_kw.get('tick1On', False), 
                                'minor': bool(ec_ax.yaxis._minor_tick_kw.get('tick1On', False)), 
                                'labels': ec_ax.yaxis._major_tick_kw.get('label1On', False), 
-                               'title': bool(ec_ax.get_ylabel())},
+                               'title': False},  # EC ylabel is on right, not left
                     'right':  {'spine': _get_spine_visible(ec_ax, 'right'), 'ticks': ec_ax.yaxis._major_tick_kw.get('tick2On', True), 
                                'minor': bool(ec_ax.yaxis._minor_tick_kw.get('tick2On', False)), 
                                'labels': ec_ax.yaxis._major_tick_kw.get('label2On', True), 
-                               'title': bool(ec_ax.get_ylabel())},
+                               'title': ec_ylabel_visible},  # True if ylabel is not empty
                 }
             else:
                 ec_wasd = None
@@ -1266,6 +1293,47 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                     'x': getattr(ec_ax.xaxis, 'labelpad', None),
                     'y': getattr(ec_ax.yaxis, 'labelpad', None),
                 }
+            # Spine and tick widths (l command) for undo
+            op_spines_snap = {}
+            for name in ('bottom', 'top', 'left', 'right'):
+                sp = ax.spines.get(name)
+                if sp:
+                    op_spines_snap[name] = float(sp.get_linewidth())
+            op_ticks_snap = {
+                'x_major': _axis_tick_width(ax.xaxis, 'major'),
+                'x_minor': _axis_tick_width(ax.xaxis, 'minor'),
+                'y_major': _axis_tick_width(ax.yaxis, 'major'),
+                'y_minor': _axis_tick_width(ax.yaxis, 'minor'),
+            }
+            ec_spines_snap = None
+            ec_ticks_snap = None
+            ec_line_style = None
+            if ec_ax is not None:
+                ec_spines_snap = {}
+                for name in ('bottom', 'top', 'left', 'right'):
+                    sp = ec_ax.spines.get(name)
+                    if sp:
+                        ec_spines_snap[name] = float(sp.get_linewidth())
+                ec_ticks_snap = {
+                    'x_major': _axis_tick_width(ec_ax.xaxis, 'major'),
+                    'x_minor': _axis_tick_width(ec_ax.xaxis, 'minor'),
+                    'y_major': _axis_tick_width(ec_ax.yaxis, 'major'),
+                    'y_minor': _axis_tick_width(ec_ax.yaxis, 'minor'),
+                }
+                ln = getattr(ec_ax, '_ec_line', None)
+                if ln is None and ec_ax.lines:
+                    try:
+                        ln = ec_ax.lines[0]
+                    except Exception:
+                        ln = None
+                if ln is not None:
+                    try:
+                        ec_line_style = {
+                            'color': ln.get_color(),
+                            'linewidth': float(ln.get_linewidth() or 1.0),
+                        }
+                    except Exception:
+                        pass
             state_history.append({
                 'note': note,
                 'fig_size': (fig_w, fig_h),
@@ -1309,6 +1377,11 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                     'right_x': float(getattr(ec_ax, '_right_ylabel_manual_offset_x_pts', 0.0) or 0.0) if ec_ax is not None else 0.0,
                     'right_y': float(getattr(ec_ax, '_right_ylabel_manual_offset_y_pts', 0.0) or 0.0) if ec_ax is not None else 0.0,
                 } if ec_ax is not None else None,
+                'op_spines': op_spines_snap,
+                'op_ticks': op_ticks_snap,
+                'ec_spines': ec_spines_snap,
+                'ec_ticks': ec_ticks_snap,
+                'ec_line_style': ec_line_style,
             })
             if len(state_history) > 40:
                 state_history.pop(0)
@@ -1546,24 +1619,31 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                                 ec_ax.tick_params(axis='x', which='minor', **{tick_key: bool(st['minor'])})
                             if 'labels' in st:
                                 ec_ax.tick_params(axis='x', which='major', **{label_key: bool(st['labels'])})
-                        elif side == 'right':  # d - only EC controls
+                        elif side == 'right':  # d - only EC controls (EC y-axis is on right by default)
                             if 'ticks' in st:
                                 ec_ax.tick_params(axis='y', which='major', left=False, right=bool(st['ticks']))
                             if 'minor' in st:
                                 ec_ax.tick_params(axis='y', which='minor', left=False, right=bool(st['minor']))
                             if 'labels' in st:
                                 ec_ax.tick_params(axis='y', which='major', labelleft=False, labelright=bool(st['labels']))
+                            print(f"[DEBUG UNDO] EC right restored: ticks={st.get('ticks')}, labels={st.get('labels')}")
                         # Title restoration
                         if side == 'top' and 'title' in st:
                             setattr(ec_ax, '_top_xlabel_on', bool(st['title']))
                         elif side == 'right' and 'title' in st:
                             # EC right title is actual ylabel, not duplicate
+                            print(f"[DEBUG UNDO] EC right title state: {st['title']}, current ylabel: '{ec_ax.get_ylabel()}'")
                             if bool(st['title']):
-                                # Keep existing ylabel or restore from ec_labels
-                                pass  # ylabel already restored above
+                                # Ylabel should be visible - restore from _stored_ylabel if it's currently empty
+                                if not ec_ax.get_ylabel() and hasattr(ec_ax, '_stored_ylabel'):
+                                    ec_ax.set_ylabel(ec_ax._stored_ylabel)
+                                    print(f"[DEBUG UNDO] Restored EC ylabel from _stored_ylabel: '{ec_ax._stored_ylabel}'")
                             else:
                                 # Hide ylabel
+                                if not hasattr(ec_ax, '_stored_ylabel'):
+                                    ec_ax._stored_ylabel = ec_ax.get_ylabel()
                                 ec_ax.set_ylabel('')
+                                print(f"[DEBUG UNDO] Hid EC ylabel, stored: '{ec_ax._stored_ylabel}'")
                 # Re-position titles using UI module functions
                 try:
                     # Build current tick state dict for UI functions
@@ -1595,11 +1675,12 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                                 ec_tick_state['b_ticks'] = st.get('ticks', True)
                                 ec_tick_state['b_labels'] = st.get('labels', True)
                             elif side == 'left':
-                                ec_tick_state['l_ticks'] = st.get('ticks', False)
-                                ec_tick_state['l_labels'] = st.get('labels', False)
+                                ec_tick_state['l_ticks'] = st.get('ticks', False)  # EC: left is off by default
+                                ec_tick_state['l_labels'] = st.get('labels', False)  # EC: left labels off
                             elif side == 'right':
-                                ec_tick_state['r_ticks'] = st.get('ticks', True)
-                                ec_tick_state['r_labels'] = st.get('labels', True)
+                                ec_tick_state['r_ticks'] = st.get('ticks', True)  # EC: right ticks ON by default
+                                ec_tick_state['r_labels'] = st.get('labels', True)  # EC: right labels ON by default
+                        print(f"[DEBUG UNDO] EC tick_state: r_ticks={ec_tick_state.get('r_ticks')}, r_labels={ec_tick_state.get('r_labels')}")
                     # Position titles
                     _ui_position_top_xlabel(ax, fig, op_tick_state)
                     _ui_position_bottom_xlabel(ax, fig, op_tick_state)
@@ -1662,10 +1743,12 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                     minor = tick_lengths.get('minor')
                     if major is not None:
                         ax.tick_params(axis='both', which='major', length=major)
-                        ec_ax.tick_params(axis='both', which='major', length=major)
+                        if ec_ax is not None:
+                            ec_ax.tick_params(axis='both', which='major', length=major)
                     if minor is not None:
                         ax.tick_params(axis='both', which='minor', length=minor)
-                        ec_ax.tick_params(axis='both', which='minor', length=minor)
+                        if ec_ax is not None:
+                            ec_ax.tick_params(axis='both', which='minor', length=minor)
                     fig._tick_lengths = tick_lengths
             except Exception:
                 pass
@@ -1673,10 +1756,68 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
             try:
                 tick_dir = snap.get('tick_direction', 'out')
                 ax.tick_params(axis='both', which='both', direction=tick_dir)
-                ec_ax.tick_params(axis='both', which='both', direction=tick_dir)
+                if ec_ax is not None:
+                    ec_ax.tick_params(axis='both', which='both', direction=tick_dir)
                 fig._tick_direction = tick_dir
             except Exception:
                 pass
+            # Restore spine linewidths and tick widths (l command)
+            try:
+                op_sp = snap.get('op_spines', {})
+                if op_sp:
+                    for name, lw in op_sp.items():
+                        sp = ax.spines.get(name)
+                        if sp is not None and lw is not None:
+                            sp.set_linewidth(float(lw))
+                op_tw = snap.get('op_ticks', {})
+                if op_tw:
+                    if op_tw.get('x_major') is not None:
+                        ax.tick_params(axis='x', which='major', width=op_tw['x_major'])
+                    if op_tw.get('x_minor') is not None:
+                        ax.tick_params(axis='x', which='minor', width=op_tw['x_minor'])
+                    if op_tw.get('y_major') is not None:
+                        ax.tick_params(axis='y', which='major', width=op_tw['y_major'])
+                    if op_tw.get('y_minor') is not None:
+                        ax.tick_params(axis='y', which='minor', width=op_tw['y_minor'])
+            except Exception:
+                pass
+            try:
+                if ec_ax is not None:
+                    ec_sp = snap.get('ec_spines', {})
+                    if ec_sp:
+                        for name, lw in ec_sp.items():
+                            sp = ec_ax.spines.get(name)
+                            if sp is not None and lw is not None:
+                                sp.set_linewidth(float(lw))
+                    ec_tw = snap.get('ec_ticks', {})
+                    if ec_tw:
+                        if ec_tw.get('x_major') is not None:
+                            ec_ax.tick_params(axis='x', which='major', width=ec_tw['x_major'])
+                        if ec_tw.get('x_minor') is not None:
+                            ec_ax.tick_params(axis='x', which='minor', width=ec_tw['x_minor'])
+                        if ec_tw.get('y_major') is not None:
+                            ec_ax.tick_params(axis='y', which='major', width=ec_tw['y_major'])
+                        if ec_tw.get('y_minor') is not None:
+                            ec_ax.tick_params(axis='y', which='minor', width=ec_tw['y_minor'])
+            except Exception:
+                pass
+            # Restore EC line style (el command)
+            try:
+                ec_line_style = snap.get('ec_line_style')
+                if ec_line_style and ec_ax is not None:
+                    ln = getattr(ec_ax, '_ec_line', None)
+                    if ln is None and ec_ax.lines:
+                        try:
+                            ln = ec_ax.lines[0]
+                        except Exception:
+                            ln = None
+                    if ln is not None:
+                        if ec_line_style.get('color') is not None:
+                            ln.set_color(ec_line_style['color'])
+                        if ec_line_style.get('linewidth') is not None:
+                            ln.set_linewidth(float(ec_line_style['linewidth']))
+            except Exception:
+                pass
             # Restore visibility states
             try:
                 cb_vis = snap.get('cb_visible')
@@ -2285,6 +2426,234 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
             except Exception as e:
                 print(f"Save failed: {e}")
             print_menu(); continue
+        if cmd == 'pk':
+            try:
+                import os
+                from .utils import choose_save_path
+                try:
+                    from scipy.signal import find_peaks
+                except ImportError:
+                    print("Error: scipy is required for peak finding. Install with: pip install scipy")
+                    print_menu(); continue
+                
+                # Get operando data
+                data_array = np.asarray(im.get_array(), dtype=float)
+                if data_array.ndim != 2 or data_array.size == 0:
+                    print("Error: No operando data available.")
+                    print_menu(); continue
+                
+                extent = im.get_extent()  # (left, right, bottom, top)
+                x0, x1, y0, y1 = extent
+                x_min, x_max = (x0, x1) if x0 <= x1 else (x1, x0)
+                y_min, y_max = (y0, y1) if y0 <= y1 else (y1, y0)
+                
+                n_scans, n_x_points = data_array.shape
+                
+                # Create x-axis array
+                x_axis = np.linspace(x_min, x_max, n_x_points)
+                
+                print("\nPeak Search Menu:")
+                print("  1: Find peaks in X range")
+                print("  e: Explanation of peak searching")
+                print("  q: Back to main menu")
+                sub = _safe_input("Choose option: ").strip().lower()
+                
+                if sub == 'e':
+                    print("\n" + "="*70)
+                    print("PEAK SEARCHING EXPLANATION")
+                    print("="*70)
+                    print("\nPeak searching identifies local maxima in diffraction patterns.")
+                    print("This is useful for tracking how peak positions change over time")
+                    print("(or scan number) in operando experiments.\n")
+                    print("HOW IT WORKS:")
+                    print("1. Select X range: Choose the region where you want to find peaks")
+                    print("2. For each scan (file):")
+                    print("   - Extract intensity profile in the selected X range")
+                    print("   - Find local maxima (peaks) using scipy.signal.find_peaks")
+                    print("   - Refine peak positions using quadratic interpolation")
+                    print("3. Export results: Peak positions vs file number saved to .txt file\n")
+                    print("PARAMETERS:")
+                    print("- Prominence: Minimum height of peak relative to surrounding baseline")
+                    print("  (Higher = fewer, stronger peaks)")
+                    print("- Distance: Minimum separation between peaks (in data points)")
+                    print("  (Larger = peaks must be further apart)")
+                    print("- Width: Minimum width of peak at half maximum")
+                    print("  (Larger = broader peaks only)\n")
+                    print("OUTPUT FORMAT:")
+                    print("The exported .txt file contains:")
+                    print("  Column 1: File number (scan index, 0-based)")
+                    print("  Column 2: Peak position (X-axis value)")
+                    print("  Column 3: Peak intensity (optional, if enabled)\n")
+                    print("="*70 + "\n")
+                    print_menu(); continue
+                
+                if sub == 'q':
+                    print_menu(); continue
+                
+                if sub == '1' or sub == '':
+                    # Get X range
+                    print(f"\nCurrent X range: {x_min:.6g} to {x_max:.6g}")
+                    print("Enter X range for peak search (min max), or press Enter to use full range:")
+                    x_range_input = _safe_input("X range: ").strip()
+                    
+                    if x_range_input:
+                        try:
+                            parts = x_range_input.split()
+                            if len(parts) >= 2:
+                                x_range_min = float(parts[0])
+                                x_range_max = float(parts[1])
+                            else:
+                                print("Invalid format. Use: min max")
+                                print_menu(); continue
+                        except ValueError:
+                            print("Invalid number format.")
+                            print_menu(); continue
+                    else:
+                        x_range_min = x_min
+                        x_range_max = x_max
+                    
+                    # Clamp to valid range
+                    x_range_min = max(x_min, min(x_max, x_range_min))
+                    x_range_max = max(x_min, min(x_max, x_range_max))
+                    if x_range_min >= x_range_max:
+                        print("Invalid range: min must be < max")
+                        print_menu(); continue
+                    
+                    # Find column indices for X range
+                    col_min = int(np.argmin(np.abs(x_axis - x_range_min)))
+                    col_max = int(np.argmin(np.abs(x_axis - x_range_max)))
+                    if col_min > col_max:
+                        col_min, col_max = col_max, col_min
+                    col_max = min(col_max + 1, n_x_points)  # Include endpoint
+                    
+                    # Get parameters for peak finding
+                    print("\nPeak finding parameters:")
+                    prominence_input = _safe_input("Prominence (relative to max, default 0.1): ").strip()
+                    prominence = float(prominence_input) if prominence_input else 0.1
+                    
+                    distance_input = _safe_input("Minimum distance between peaks (data points, default 5): ").strip()
+                    distance = int(distance_input) if distance_input else 5
+                    
+                    width_input = _safe_input("Minimum peak width (data points, default 1, 0=disabled): ").strip()
+                    width = int(width_input) if width_input else 1
+                    
+                    include_intensity = _safe_input("Include peak intensity in output? (y/n, default n): ").strip().lower() == 'y'
+                    
+                    # Find peaks for each scan
+                    print(f"\nFinding peaks in X range [{x_range_min:.6g}, {x_range_max:.6g}]...")
+                    results = []
+                    
+                    for scan_idx in range(n_scans):
+                        # Extract intensity profile for this scan in X range
+                        intensity_profile = data_array[scan_idx, col_min:col_max]
+                        x_profile = x_axis[col_min:col_max]
+                        
+                        if len(intensity_profile) < 3:
+                            continue
+                        
+                        # Find peaks
+                        try:
+                            # Calculate prominence threshold
+                            max_intensity = np.max(intensity_profile)
+                            min_intensity = np.min(intensity_profile)
+                            prominence_abs = (max_intensity - min_intensity) * prominence
+                            
+                            peak_kwargs = {
+                                'prominence': prominence_abs if prominence_abs > 0 else None,
+                                'distance': max(1, distance),
+                            }
+                            if width > 0:
+                                peak_kwargs['width'] = width
+                            
+                            # Remove None values
+                            peak_kwargs = {k: v for k, v in peak_kwargs.items() if v is not None}
+                            
+                            peak_indices, peak_properties = find_peaks(intensity_profile, **peak_kwargs)
+                            
+                            # Refine peak positions using quadratic interpolation
+                            for peak_idx in peak_indices:
+                                if peak_idx == 0 or peak_idx == len(intensity_profile) - 1:
+                                    peak_x = x_profile[peak_idx]
+                                    peak_intensity = intensity_profile[peak_idx]
+                                else:
+                                    # Quadratic interpolation for sub-pixel accuracy
+                                    y1 = intensity_profile[peak_idx - 1]
+                                    y2 = intensity_profile[peak_idx]
+                                    y3 = intensity_profile[peak_idx + 1]
+                                    x1 = x_profile[peak_idx - 1]
+                                    x2 = x_profile[peak_idx]
+                                    x3 = x_profile[peak_idx + 1]
+                                    
+                                    denom = (y1 - 2*y2 + y3)
+                                    if abs(denom) > 1e-12:
+                                        dx = 0.5 * (y1 - y3) / denom
+                                        if -0.6 < dx < 0.6:
+                                            peak_x = x2 + dx * (x3 - x1) / 2.0
+                                            peak_intensity = y2 + 0.5 * dx * (y3 - y1)
+                                        else:
+                                            peak_x = x2
+                                            peak_intensity = y2
+                                    else:
+                                        peak_x = x2
+                                        peak_intensity = y2
+                                
+                                if include_intensity:
+                                    results.append((scan_idx, peak_x, peak_intensity))
+                                else:
+                                    results.append((scan_idx, peak_x))
+                        except Exception as e:
+                            # Skip this scan if peak finding fails
+                            continue
+                    
+                    if not results:
+                        print("No peaks found in the selected X range.")
+                        print_menu(); continue
+                    
+                    # Save results
+                    folder = choose_save_path(file_paths, purpose="peak search export")
+                    if not folder:
+                        print_menu(); continue
+                    
+                    print(f"\nChosen path: {folder}")
+                    fname = _safe_input("Export filename (default: peaks.txt): ").strip()
+                    if not fname:
+                        fname = "peaks.txt"
+                    if not fname.endswith('.txt'):
+                        fname += '.txt'
+                    
+                    target = fname if os.path.isabs(fname) else os.path.join(folder, fname)
+                    if os.path.exists(target):
+                        yn = _safe_input(f"'{os.path.basename(target)}' exists. Overwrite? (y/n): ").strip().lower()
+                        if yn != 'y':
+                            print_menu(); continue
+                    
+                    # Write results
+                    try:
+                        with open(target, 'w') as f:
+                            if include_intensity:
+                                f.write("# File number\tPeak position\tPeak intensity\n")
+                                for scan_idx, peak_x, peak_intensity in results:
+                                    f.write(f"{scan_idx}\t{peak_x:.6f}\t{peak_intensity:.6f}\n")
+                            else:
+                                f.write("# File number\tPeak position\n")
+                                for result in results:
+                                    if len(result) == 2:
+                                        scan_idx, peak_x = result
+                                        f.write(f"{scan_idx}\t{peak_x:.6f}\n")
+                                    else:
+                                        scan_idx, peak_x, _ = result
+                                        f.write(f"{scan_idx}\t{peak_x:.6f}\n")
+                        print(f"Peak positions exported to {target}")
+                        print(f"Found {len(results)} peaks across {len(set(r[0] for r in results))} scans")
+                    except Exception as e:
+                        print(f"Error saving file: {e}")
+                else:
+                    print("Invalid option.")
+            except Exception as e:
+                print(f"Error in peak search: {e}")
+                import traceback
+                traceback.print_exc()
+            print_menu(); continue
         if cmd == 'h':
             # Always read fresh value from attribute to avoid stale cached value
             ax_h_in = getattr(ax, '_fixed_ax_h_in', ax_h_in)
@@ -2724,6 +3093,8 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                                 try: axis._stored_ylabel = axis.get_ylabel()
                                 except Exception: axis._stored_ylabel = ''
                             axis.set_ylabel("")
+                        # Set flag for right title state (used by save/export)
+                        axis._right_ylabel_on = bool(wasd_state['right']['title'])
                         # Left ylabel is disabled for EC (hide any duplicate artist)
                         # Note: EC uses the actual ylabel which is already on the right side
                     else:
@@ -2747,7 +3118,10 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
                     if 'left' in changed_sides:
                         _ui_position_left_ylabel(axis, fig, current_tick_state)
                     if 'right' in changed_sides:
-                        _ui_position_right_ylabel(axis, fig, current_tick_state)
+                        # EC axes use actual ylabel on right, not duplicate artist
+                        # Skip _ui_position_right_ylabel for EC to avoid creating unwanted duplicate
+                        if not is_ec:
+                            _ui_position_right_ylabel(axis, fig, current_tick_state)
                 
                 print(_colorize_inline_commands("WASD toggles: direction (w/a/s/d) x action (1..5)"))
                 print(_colorize_inline_commands("  1=spine   2=ticks   3=minor ticks   4=tick labels   5=axis title"))
@@ -4039,7 +4413,7 @@ def operando_ec_interactive_menu(fig, ax, im, cbar, ec_ax, file_paths=None):
             print_menu()
         elif cmd == 'i':
             # Load a .bps/.bpsg/.bpcfg style and apply
-            # Applies style properties from commands: oc, ow, ew, h, el, t, l, f, g, r
+            # Applies: oc, ow, ew, h, el, t, l, f, g, r, v; .bpsg also applies ox, oy, oz, or, et, ex, ey, er (axes_geometry + ec y_mode)
             try:
                 path = choose_style_file(file_paths, purpose="style import")
                 if not path: