batplot 1.8.3__py3-none-any.whl → 1.8.5__py3-none-any.whl

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",
@@ -885,7 +886,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",
@@ -2285,6 +2287,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)