", None)]
+ try:
+ spectrum_sel.value = None
+ except Exception:
+ pass
+ try:
+ _update_spectrum_counter()
+ except Exception:
+ pass
+ return
+ prev_val = spectrum_sel.value
+ spectrum_sel.options = opts_local
+ valid_values = [val for _, val in opts_local]
+ if prev_val in valid_values:
+ try:
+ spectrum_sel.value = prev_val
+ except Exception:
+ pass
+ else:
+ try:
+ spectrum_sel.value = valid_values[0]
+ except Exception:
+ pass
+ try:
+ _update_spectrum_counter()
+ except Exception:
+ pass
+
+ material_dd.observe(_refresh_spectrum_options_deconv, names="value")
+ conditions_dd.observe(_refresh_spectrum_options_deconv, names="value")
+ include_bad_cb.observe(_refresh_spectrum_options_deconv, names="value")
+ # Primary fit range (Range 1). Additional ranges can be added dynamically via a button.
+ fit_range = widgets.FloatRangeSlider(
+ value=[xmin, xmax],
+ min=xmin,
+ max=xmax,
+ step=(xmax - xmin) / 1000 or 1.0,
+ description="Range 1",
+ continuous_update=False,
+ readout_format=".1f",
+ layout=widgets.Layout(width="90%"),
+ )
+
+ # Dynamic range slider list (initial contains Range 1). Limit to 3 total to mirror previous functionality.
+ range_sliders = [fit_range]
+
+ # Persist the most recently chosen Fit X-ranges across spectrum switches.
+ # Stored as a list of (lo, hi) floats, length 1..3.
+ persisted_fit_ranges = None
+
+ add_range_btn = widgets.Button(
+ description="Add another range",
+ button_style="info",
+ layout=widgets.Layout(width="180px"),
+ tooltip="Insert an additional fit range (up to 3).",
+ )
+
+ def _make_range_slider(n: int):
+ # n is 1-based index
+ return widgets.FloatRangeSlider(
+ value=[xmin, xmax],
+ min=xmin,
+ max=xmax,
+ step=(xmax - xmin) / 1000 or 1.0,
+ description=f"Range {n}",
+ continuous_update=False,
+ readout_format=".1f",
+ layout=widgets.Layout(width="90%"),
+ )
+
+ def _clamp_ranges_to_span(ranges, x_min: float, x_max: float):
+ """Clamp ranges to [x_min, x_max]; fall back to full-span if collapsed."""
+ out = []
+ if ranges is None:
+ ranges = []
+ for lo, hi in ranges:
+ try:
+ lo_f = float(lo)
+ hi_f = float(hi)
+ except Exception:
+ continue
+ lo_f, hi_f = (min(lo_f, hi_f), max(lo_f, hi_f))
+ lo_f = max(float(x_min), lo_f)
+ hi_f = min(float(x_max), hi_f)
+ # If a range collapses after clamping, use the full span.
+ if not (hi_f > lo_f):
+ lo_f, hi_f = float(x_min), float(x_max)
+ out.append((lo_f, hi_f))
+ if len(out) >= 3:
+ break
+ if not out:
+ out = [(float(x_min), float(x_max))]
+ return out
+
+ def _apply_ranges_to_sliders(ranges, x_min: float, x_max: float):
+ """Ensure slider count matches ranges and apply limits/values."""
+ nonlocal range_sliders
+ safe = _clamp_ranges_to_span(ranges, x_min, x_max)
+
+ target_n = max(1, min(3, len(safe)))
+ # Remove extras
+ try:
+ while len(range_sliders) > target_n:
+ range_sliders.pop()
+ except Exception:
+ pass
+ # Add missing
+ try:
+ while len(range_sliders) < target_n:
+ sl_new = _make_range_slider(len(range_sliders) + 1)
+ range_sliders.append(sl_new)
+ try:
+ sl_new.observe(_on_fit_range_change, names="value")
+ except Exception:
+ pass
+ except Exception:
+ pass
+
+ step = (x_max - x_min) / 1000 or 1.0
+ for sl, (lo, hi) in zip(range_sliders, safe[:target_n]):
+ try:
+ sl.min = float(x_min)
+ sl.max = float(x_max)
+ sl.step = float(step)
+ sl.value = [float(lo), float(hi)]
+ except Exception:
+ pass
+
+ try:
+ _renumber_range_sliders()
+ except Exception:
+ pass
+ try:
+ add_range_btn.disabled = len(range_sliders) >= 3
+ add_range_btn.tooltip = (
+ "Maximum of 3 ranges reached" if len(range_sliders) >= 3
+ else "Insert an additional fit range (up to 3)."
+ )
+ except Exception:
+ pass
+ try:
+ _refresh_range_box()
+ except Exception:
+ pass
+
+ range_sliders_box = widgets.VBox([widgets.HBox([fit_range])])
+
+ def _renumber_range_sliders():
+ """Update slider descriptions to maintain contiguous numbering after add/remove."""
+ try:
+ for i, sl in enumerate(range_sliders, start=1):
+ sl.description = f"Range {i}"
+ except Exception:
+ pass
+
+ def _remove_range(slider):
+ try:
+ if slider in range_sliders and len(range_sliders) > 1:
+ range_sliders.remove(slider)
+ _renumber_range_sliders()
+ # Re-enable add button if previously disabled due to max reached
+ try:
+ if len(range_sliders) < 3:
+ add_range_btn.disabled = False
+ add_range_btn.tooltip = "Insert an additional fit range (up to 3)."
+ except Exception:
+ pass
+ _refresh_range_box()
+ _on_fit_range_change()
+ except Exception:
+ pass
+
+ def _refresh_range_box():
+ try:
+ rows = []
+ multi = len(range_sliders) > 1
+ for sl in range_sliders:
+ if multi:
+ rm_btn = widgets.Button(
+ description="Remove Range",
+ button_style="warning",
+ layout=widgets.Layout(width="130px"),
+ tooltip="Remove this fit range",
+ )
+ def _bind(btn, s=sl):
+ try:
+ btn.on_click(lambda _b: _remove_range(s))
+ except Exception:
+ pass
+ _bind(rm_btn)
+ rows.append(widgets.HBox([sl, rm_btn]))
+ else:
+ rows.append(widgets.HBox([sl]))
+ range_sliders_box.children = rows
+ except Exception:
+ pass
+
+ def _add_range(_b=None):
+ if len(range_sliders) >= 3:
+ try:
+ add_range_btn.disabled = True
+ add_range_btn.tooltip = "Maximum of 3 ranges reached"
+ except Exception:
+ pass
+ return
+ idx_new = len(range_sliders) + 1
+ sl = _make_range_slider(idx_new)
+ range_sliders.append(sl)
+ try:
+ sl.observe(_on_fit_range_change, names="value")
+ except Exception:
+ pass
+ _renumber_range_sliders()
+ _refresh_range_box()
+ if len(range_sliders) >= 3:
+ try:
+ add_range_btn.disabled = True
+ add_range_btn.tooltip = "Maximum of 3 ranges reached"
+ except Exception:
+ pass
+ _on_fit_range_change()
+
+ add_range_btn.on_click(_add_range)
+ # Per-peak default seeds (no global center/sigma controls)
+ PER_PEAK_DEFAULT_CENTER_WINDOW = 5.0
+ PER_PEAK_DEFAULT_SIGMA = 10.0
+ SESSION_WINDOW_MARGIN = 1.0 # cm⁻¹ margin used when sizing session peak window vs existing peaks
+ # Defaults for reset operations
+ DEFAULT_ALPHA = 0.5
+ DEFAULT_INCLUDE = True
+ CENTER_MODE_WINDOW = "Window"
+ CENTER_MODE_EXACT = "Exact"
+ CENTER_MODE_OPTIONS = [
+ (CENTER_MODE_WINDOW, CENTER_MODE_WINDOW),
+ (CENTER_MODE_EXACT, CENTER_MODE_EXACT),
+ ]
+
+ def _normalize_center_mode_value(val):
+ mode = str(val).strip() if isinstance(val, str) else ""
+ if not mode:
+ return CENTER_MODE_WINDOW
+ lowered = mode.lower()
+ if lowered == "auto": # legacy
+ return CENTER_MODE_WINDOW
+ if lowered == "manual": # legacy
+ return CENTER_MODE_EXACT
+ if lowered == CENTER_MODE_WINDOW.lower():
+ return CENTER_MODE_WINDOW
+ if lowered == CENTER_MODE_EXACT.lower():
+ return CENTER_MODE_EXACT
+ return CENTER_MODE_WINDOW
+ default_fit_range_value = (float(fit_range.value[0]), float(fit_range.value[1]))
+ # Fit button (manual trigger for fitting)
+ fit_btn = widgets.Button(
+ description="Fit",
+ tooltip="Run fit using current settings",
+ button_style="primary",
+ layout=widgets.Layout(width="80px"),
+ )
+ add_peaks_btn = widgets.Button(
+ description="Add peaks",
+ tooltip="Add new peak(s)",
+ button_style="info",
+ layout=widgets.Layout(width="110px"),
+ )
+ # Dedicated Delete peaks button (wired later)
+ delete_peaks_btn = widgets.Button(
+ description="Delete peaks",
+ button_style="warning",
+ layout=widgets.Layout(width="120px"),
+ )
+ accept_new_peaks_btn = widgets.Button(
+ description="Accept new peak(s)",
+ button_style="success",
+ layout=widgets.Layout(width="150px"),
+ )
+ # Iterative correction button to minimize reduced chi-square via coordinate descent
+ iter_btn = widgets.Button(
+ description="Optimize α values",
+ button_style="info",
+ layout=widgets.Layout(width="185px"),
+ tooltip=(
+ "Iteratively adjust included peaks' α values to minimize error."
+ ),
+ )
+ cancel_fit_btn = widgets.Button(
+ description="Cancel Fit",
+ button_style="danger",
+ layout=widgets.Layout(width="150px"),
+ tooltip="Interrupt the current fit or optimization run",
+ )
+ redo_new_peaks_btn = widgets.Button(
+ description="Redo new peaks",
+ button_style="warning",
+ layout=widgets.Layout(width="140px"),
+ )
+ cancel_new_peaks_btn = widgets.Button(
+ description="Cancel peak addition",
+ button_style="danger",
+ layout=widgets.Layout(width="190px"),
+ )
+ save_btn = widgets.Button(
+ description="Save for spectrum",
+ button_style="success",
+ tooltip="Save deconvolution results for the current spectrum",
+ )
+ close_btn = widgets.Button(description="Close", button_style="danger")
+ # Delete-mode action buttons (shown only in delete mode)
+ accept_deletions_btn = widgets.Button(
+ description="Accept deletions",
+ button_style="success",
+ layout=widgets.Layout(width="160px"),
+ )
+ redo_deletions_btn = widgets.Button(
+ description="Redo deletions",
+ button_style="warning",
+ layout=widgets.Layout(width="140px"),
+ )
+ cancel_deletions_btn = widgets.Button(
+ description="Cancel deletions",
+ button_style="danger",
+ layout=widgets.Layout(width="170px"),
+ )
+ # Dedicated status label to avoid Output-widget buffering issues
+ status_html = widgets.HTML(value="")
+ optimize_status_html = widgets.HTML(value="")
+ # Replace Output-based logging with a single HTML widget to avoid renderer
+ # double-echo issues in some notebook front-ends.
+ log_html = widgets.HTML(value="")
+ # De-duplicate log messages: avoid echoing the same text twice in quick succession
+ # Make this thread-safe since some logs originate from worker threads.
+ last_msg_text = ""
+ last_msg_ts = 0.0
+ log_lock = threading.Lock()
+ # --- Change tracking for session summary (on Close) ---
+ _deconv_changes = {
+ "saved": [], # list[(idx, count_components)]
+ "quality": [], # list[(idx, new_quality)]
+ "iter": [], # list[(idx, start_redchi, final_redchi, improvements)]
+ }
+
+ def _log_once(message: str, *, wait: bool = True, clear: bool = True):
+ nonlocal last_msg_text, last_msg_ts
+ # Normalize message to minimize false negatives due to stray whitespace
+ msg_norm = str(message).rstrip()
+ try:
+ now = time.time()
+ except Exception:
+ now = 0.0
+ # Use a small lock to serialize dedup checks across threads
+ with log_lock:
+ # Suppress duplicates of identical text within ~1.0s window
+ if msg_norm == last_msg_text and (now - last_msg_ts) < 1.0:
+ return
+ # Update the HTML log widget directly to avoid Output buffering quirks.
+ try:
+ # Escape to prevent unintended HTML rendering; keep it simple text.
+ safe = html.escape(msg_norm)
+ log_html.value = f"{safe}
"
+ except Exception:
+ # As a last resort, try printing to the notebook output
+ try:
+ print(msg_norm)
+ except Exception:
+ pass
+ last_msg_text = msg_norm
+ last_msg_ts = now
+
+ def _append_status(message: str):
+ """Append a status line (monospace) without clearing previous messages.
+
+ Keeps a running log in the log_html widget so multiple actions are visible.
+ """
+ try:
+ msg_norm = html.escape(str(message).rstrip())
+ except Exception:
+ msg_norm = str(message)
+ try:
+ prev = str(getattr(log_html, 'value', ''))
+ # Ensure container div exists; append a new line
+ if not prev:
+ log_html.value = f"{msg_norm}
"
+ else:
+ # Insert before closing div tag when present
+ if prev.endswith(""):
+ log_html.value = prev[:-6] + "\n" + msg_norm + ""
+ else:
+ log_html.value = prev + "\n" + msg_norm
+ except Exception:
+ # Fallback to print if HTML update fails
+ try:
+ print(message)
+ except Exception:
+ pass
+
+ # Reset buttons for globals and all
+ reset_all_btn = widgets.Button(
+ description="Reset all peak parameters to defaults",
+ button_style="warning",
+ tooltip="Reset all per-peak sliders and selections to defaults",
+ layout=widgets.Layout(width="340px"),
+ )
+
+ # Cancellation/interrupt support for long-running fits
+ # Global cancellation token for long-running workflows (iteration).
+ # Note: Do NOT replace this Event with a new instance elsewhere; it must remain
+ # stable so a single set() call cancels the entire workflow.
+ cancel_event = threading.Event()
+ fit_thread = None
+ iter_thread = None
+ fit_cancel_token = None # points to the active fit's cancel event, if any
+ iterating_in_progress = False # suppress per-fit status updates while iterating
+ cancel_fit_btn_frozen = False # suppress show/hide toggles to prevent flicker
+ # Snapshot of reduced chi-square at the moment the user clicks Iterate
+ iter_start_redchi = None
+ # Final reduced chi-square once iteration completes and a flag to show a summary
+ iter_final_redchi = None
+ iter_summary_pending = False
+ # Helper to marshal UI updates back onto the notebook's main IOLoop
+ try:
+ from tornado.ioloop import IOLoop as _IOLoop
+ except Exception:
+ _IOLoop = None
+ # Capture the main thread's IOLoop now; using current() inside a worker thread
+ # can create a new, non-running loop which would drop callbacks.
+ try:
+ _MAIN_IOLOOP = _IOLoop.current() if _IOLoop is not None else None
+ except Exception:
+ _MAIN_IOLOOP = None
+
+ def _on_main_thread(fn, *args, **kwargs):
+ """Schedule *fn* to run on the notebook's main UI thread when possible."""
+ try:
+ if _MAIN_IOLOOP is not None:
+ _MAIN_IOLOOP.add_callback(lambda: fn(*args, **kwargs))
+ return
+ except Exception:
+ pass
+ try: # Fall back to asyncio event loop used by ipykernel (JupyterLab/VS Code)
+ import asyncio
+
+ loop = asyncio.get_event_loop()
+ if loop is not None and loop.is_running():
+ loop.call_soon_threadsafe(fn, *args, **kwargs)
+ return
+ except Exception:
+ pass
+ # As a last resort, execute immediately (may succeed in synchronous shells)
+ try:
+ fn(*args, **kwargs)
+ except Exception:
+ pass
+
+ # Dynamic per-peak controls: include checkbox + per-peak parameter sliders/locks
+ alpha_sliders = [] # list[widgets.FloatSlider] (fraction α)
+ include_checkboxes = [] # list[widgets.Checkbox]
+ center_sliders = [] # list[widgets.FloatSlider] direct center (μ)
+ # Map the ordering of per-peak sliders to original peak indices. The existing logic
+ # builds slider lists in ascending order of original peak indices, but later fit
+ # code incorrectly indexes sliders with the original peak index (which may be
+ # sparse), causing parameter tweaks to be ignored. We capture the ordered list
+ # here and keep it updated on rebuild so we can translate original peak indices
+ # to slider positions reliably.
+ center_slider_peak_indices = [] # list[int] parallel to center_sliders
+ # Added lists for peak label/header synchronization post-fit
+ peak_label_widgets = [] # list[widgets.HTML] per-peak headers shown in UI
+ original_peak_centers = [] # list[float] detected (pre-fit) peak centers
+ last_active_ranges = [] # list[(lo, hi)] currently active fit ranges for header range status
+ sigma_sliders = [] # list[widgets.FloatSlider]
+ amplitude_sliders = [] # list[widgets.FloatSlider] amplitude A
+ center_window_sliders = [] # list[widgets.FloatSlider] center ± window width
+ # Mode toggles (Auto vs Manual) for A, μ, σ; alpha is always Manual per spec
+ amplitude_mode_toggles = [] # list[widgets.ToggleButtons]
+ center_mode_toggles = [] # list[widgets.ToggleButtons]
+ sigma_mode_toggles = [] # list[widgets.ToggleButtons]
+ # Legacy lock checkboxes retained as empty lists for backward compatibility with existing logic
+ lock_alpha_checkboxes = []
+ lock_center_checkboxes = []
+ lock_sigma_checkboxes = []
+ peak_controls_box = widgets.VBox([])
+ # Container (previously Accordion) for peak sections; now simple VBox to avoid nested blank accordion
+ peak_accordion = widgets.VBox([])
+ globals()['peak_accordion'] = peak_accordion
+ excluded_peaks_html = widgets.HTML(value="")
+ # Map original peak index -> accordion position for title updates after fit
+ included_index_map = {}
+ # Container displayed in UI
+ peak_controls_section = widgets.VBox([peak_controls_box])
+ # Per-spectrum peak center bookkeeping: maps spectrum idx -> {peak_idx: {'initial': float, 'user': float, 'fit': float | None}}
+ peak_center_state_by_idx = {}
+ # Track which peaks are currently rendered so range changes can diff efficiently
+ previous_in_range_indices: set[int] = set()
+
+ # Guard to suppress redundant fits during bulk programmatic updates
+ bulk_update_in_progress = False
+ # Lightweight reentrancy/debounce guards to avoid duplicate callbacks
+ on_spectrum_change_inflight = False
+ last_on_spectrum_change_ts = 0.0
+ fit_update_inflight = False
+ last_fit_update_ts = 0.0
+
+ # Lightweight per-button click de-bounce to avoid double-firing handlers
+ last_click_ts = {}
+
+ def _recent_click(key: str, min_interval: float = 0.35) -> bool:
+ try:
+ now = time.time()
+ except Exception:
+ now = 0.0
+ last = last_click_ts.get(key, 0.0)
+ if (now - last) < min_interval:
+ return True
+ last_click_ts[key] = now
+ return False
+
+ def _snapshot_current_controls():
+ """Best-effort snapshot of current UI widget values.
+
+ Important: this is intentionally *not* used to carry state between spectra.
+ It exists to keep internal bookkeeping consistent (e.g., during range
+ rebuilds or when lazy widgets materialize).
+ """
+ try:
+ idx = spectrum_sel.value
+ except Exception:
+ idx = None
+ if idx is None:
+ return
+ # Capture current center slider values into the per-spectrum state for this
+ # currently-selected idx only (the dict is cleared on spectrum change).
+ try:
+ state = peak_center_state_by_idx.setdefault(idx, {})
+ for pos, sl in enumerate(center_sliders):
+ try:
+ orig_idx = (
+ center_slider_peak_indices[pos]
+ if pos < len(center_slider_peak_indices)
+ else pos
+ )
+ except Exception:
+ orig_idx = pos
+ try:
+ v = float(getattr(sl, 'value', np.nan))
+ except Exception:
+ v = getattr(sl, 'value', None)
+ entry = state.setdefault(orig_idx, {})
+ if entry.get('initial') is None:
+ entry['initial'] = v
+ entry['user'] = v
+ except Exception:
+ pass
+
+
+
+ def _on_include_toggle(*_):
+ """Handle include checkbox toggles without rebuilding the per-peak UI."""
+ try:
+ if iterating_in_progress or bulk_update_in_progress:
+ # Still snapshot state so iteration worker can see updated flags
+ _snapshot_current_controls()
+ return
+ except Exception:
+ pass
+ _snapshot_current_controls()
+ try:
+ status_html.value = (
+ "Include toggled. Click Fit to update."
+ )
+ except Exception:
+ pass
+
+ def _on_alpha_change(*_):
+ """Handle alpha slider changes without rebuilding the per-peak UI."""
+ try:
+ if iterating_in_progress or bulk_update_in_progress:
+ return
+ except Exception:
+ pass
+ _snapshot_current_controls()
+ try:
+ status_html.value = (
+ "α changed. Click Fit to update."
+ )
+ except Exception:
+ pass
+
+ def _on_center_sigma_change(*_):
+ """Handle center window/initial sigma changes without rebuilding per-peak UI."""
+ try:
+ if iterating_in_progress or bulk_update_in_progress:
+ return
+ except Exception:
+ pass
+ _snapshot_current_controls()
+ try:
+ status_html.value = (
+ "Parameters changed. Click Fit to "
+ "update."
+ )
+ except Exception:
+ pass
+
+ def _format_center_value(val):
+ try:
+ v = float(val)
+ except Exception:
+ return "--"
+ try:
+ if 'np' in globals():
+ if bool(np.isfinite(v)):
+ return f"{v:.1f}"
+ return "--"
+ except Exception:
+ pass
+ try:
+ import math
+
+ if math.isfinite(v):
+ return f"{v:.1f}"
+ except Exception:
+ pass
+ return "--"
+
+ def _set_peak_initial_center(spectrum_idx, peak_idx, value):
+ state = peak_center_state_by_idx.setdefault(spectrum_idx, {})
+ peak_state = state.setdefault(peak_idx, {})
+ try:
+ peak_state['initial'] = float(value)
+ except Exception:
+ peak_state['initial'] = value
+ if peak_state.get('user') is None:
+ peak_state['user'] = peak_state.get('initial')
+
+ def _set_peak_user_center(spectrum_idx, peak_idx, value):
+ state = peak_center_state_by_idx.setdefault(spectrum_idx, {})
+ peak_state = state.setdefault(peak_idx, {})
+ try:
+ peak_state['user'] = float(value)
+ except Exception:
+ peak_state['user'] = value
+
+ def _set_peak_fit_center(spectrum_idx, peak_idx, value):
+ state = peak_center_state_by_idx.setdefault(spectrum_idx, {})
+ peak_state = state.setdefault(peak_idx, {})
+ try:
+ peak_state['fit'] = float(value)
+ except Exception:
+ peak_state['fit'] = value
+
+ def _update_peak_toggle_label(peak_idx: int, *, spectrum_idx=None):
+ if spectrum_idx is None:
+ try:
+ spectrum_idx = spectrum_sel.value
+ except Exception:
+ spectrum_idx = current_idx_deconv
+ if spectrum_idx is None:
+ return
+ state = peak_center_state_by_idx.get(spectrum_idx, {})
+ peak_state = state.get(peak_idx, {})
+ user_val = peak_state.get('user', peak_state.get('initial'))
+ fit_val = peak_state.get('fit')
+ if fit_val is None:
+ fit_val = user_val
+ entry = None
+ try:
+ if isinstance(peak_box_cache, dict):
+ entry = peak_box_cache.get(peak_idx)
+ except Exception:
+ entry = None
+ if not entry:
+ return
+ toggle = entry.get('toggle')
+ if toggle is None:
+ return
+ toggle.description = (
+ f"Peak {peak_idx + 1} @ {_format_center_value(user_val)} → "
+ f"{_format_center_value(fit_val)} cm⁻¹"
+ )
+
+ def _bind_center_slider(slider, peak_idx, spectrum_idx):
+ def _on_change(change):
+ try:
+ new_val = change.get('new')
+ except Exception:
+ new_val = None
+ _set_peak_user_center(spectrum_idx, peak_idx, new_val)
+ _update_peak_toggle_label(peak_idx, spectrum_idx=spectrum_idx)
+ _on_center_sigma_change(change)
+
+ try:
+ slider.observe(_on_change, names="value")
+ except Exception:
+ pass
+
+ def _on_fit_range_change(*_):
+ """Only Fit X-range changes should rebuild the per-peak controls."""
+ nonlocal persisted_fit_ranges
+ try:
+ if iterating_in_progress or bulk_update_in_progress:
+ return
+ except Exception:
+ pass
+ # Snapshot first so states persist across rebuild
+ _snapshot_current_controls()
+ try:
+ persisted_fit_ranges = _current_fit_ranges()
+ except Exception:
+ pass
+ try:
+ _update_fit_range_indicator()
+ except Exception:
+ pass
+ try:
+ idx = spectrum_sel.value
+ _refresh_peak_control_widgets(idx)
+ except Exception:
+ pass
+ try:
+ status_html.value = (
+ "Fit range changed. Click Fit to "
+ "update."
+ )
+ except Exception:
+ pass
+
+ # Track last reduced chi-square per spectrum to report refit deltas
+ last_redchi_by_idx = {}
+ # Store last successful fit result per spectrum for Save action
+ last_result_by_idx = {}
+
+ # Plot figure: data, fit, components (dynamic)
+ fig = go.FigureWidget()
+ fig.add_scatter(x=x0.tolist(), y=y0.tolist(), mode="lines", name="Data (Norm+Corr)")
+ fig.add_scatter(
+ x=[], y=[], mode="lines", name="Composite Fit", line=dict(color="red")
+ )
+ fig.update_layout(
+ title="Peak Deconvolution (Pseudo-Voigt)",
+ xaxis_title="Wavenumber (cm⁻¹)",
+ yaxis_title="Absorbance (AU)",
+ )
+
+ # --- Add-peaks mode state ---
+ adding_mode = False
+ new_peak_xs = [] # temporary stash of user-clicked x positions (snapped to grid)
+ new_peak_windows = {} # x_new -> effective session window (min(default, min_dist_to_existing - margin))
+
+ def _hide(w):
+ try:
+ w.layout.display = "none"
+ except Exception:
+ pass
+
+ def _show(w):
+ try:
+ w.layout.display = ""
+ except Exception:
+ pass
+
+ def _hide_controls_during_fit_or_opt():
+ """Hide the same controls during Fit and optimization."""
+ try:
+ _hide(fit_btn)
+ except Exception:
+ pass
+ try:
+ _hide(add_peaks_btn)
+ except Exception:
+ pass
+ try:
+ _hide(canonize_btn)
+ except Exception:
+ pass
+ try:
+ _hide(canonize_confirm_btn)
+ except Exception:
+ pass
+ try:
+ _hide(canonize_cancel_btn)
+ except Exception:
+ pass
+ try:
+ _hide(load_canon_btn)
+ except Exception:
+ pass
+ try:
+ delete_peaks_btn.layout.display = "none"
+ except Exception:
+ pass
+ try:
+ _hide(iter_btn)
+ except Exception:
+ pass
+ try:
+ _hide(reset_all_row)
+ except Exception:
+ pass
+ try:
+ _hide(save_btn)
+ except Exception:
+ pass
+ try:
+ _hide(fit_range_row)
+ except Exception:
+ pass
+
+ def _show_controls_after_fit_or_opt():
+ """Restore controls hidden by _hide_controls_during_fit_or_opt."""
+ try:
+ _show(fit_btn)
+ except Exception:
+ pass
+ try:
+ _show(add_peaks_btn)
+ except Exception:
+ pass
+ try:
+ _show(canonize_btn)
+ except Exception:
+ pass
+ try:
+ _hide(canonize_confirm_btn)
+ except Exception:
+ pass
+ try:
+ _hide(canonize_cancel_btn)
+ except Exception:
+ pass
+ try:
+ _show(load_canon_btn)
+ except Exception:
+ pass
+ try:
+ delete_peaks_btn.layout.display = ""
+ except Exception:
+ pass
+ try:
+ _show(iter_btn)
+ except Exception:
+ pass
+ try:
+ _show(reset_all_row)
+ except Exception:
+ pass
+ try:
+ _show(save_btn)
+ except Exception:
+ pass
+ try:
+ _show(fit_range_row)
+ except Exception:
+ pass
+
+ def _set_cancel_button_mode(mode: str = "fit"):
+ label = "Cancel Fit"
+ tip = "Interrupt the current fit."
+ if str(mode).lower() == "optimize":
+ label = "Cancel Optimize"
+ tip = "Stop the running optimization sweep."
+ try:
+ cancel_fit_btn.description = label
+ cancel_fit_btn.tooltip = tip
+ except Exception:
+ pass
+
+ _set_cancel_button_mode("fit")
+
+ def _show_cancel_button():
+ # Try several display hints so the widget becomes visible across front-ends
+ for value in ("", "flex", "inline-flex", None):
+ try:
+ cancel_fit_btn.layout.display = value
+ break
+ except Exception:
+ continue
+ try:
+ cancel_fit_btn.layout.visibility = "visible"
+ except Exception:
+ pass
+ # Ensure the containing row is visible
+ try:
+ cancel_row.layout.display = ""
+ except Exception:
+ pass
+
+ def _hide_cancel_button():
+ try:
+ cancel_fit_btn.layout.display = "none"
+ except Exception:
+ pass
+ try:
+ cancel_fit_btn.layout.visibility = "hidden"
+ except Exception:
+ pass
+ # Hide the containing row when not needed
+ try:
+ cancel_row.layout.display = "none"
+ except Exception:
+ pass
+
+ # Show/Hide and enablement for the Cancel Fit button based on active work
+ def _update_cancel_fit_visibility():
+ # If an iterative optimization is in progress or visibility is frozen,
+ # keep the button visible and enabled without toggling to avoid flicker
+ # between the many short internal fits.
+ try:
+ if iterating_in_progress or cancel_fit_btn_frozen:
+ try:
+ _set_cancel_button_mode("optimize")
+ except Exception:
+ pass
+ try:
+ _show_cancel_button()
+ cancel_fit_btn.disabled = False
+ except Exception:
+ pass
+ return # never hide while iterating/frozen
+ except Exception:
+ pass
+ active = False
+ try:
+ active = (fit_thread is not None and fit_thread.is_alive()) or (
+ iter_thread is not None and iter_thread.is_alive()
+ )
+ except Exception:
+ pass
+ try:
+ _set_cancel_button_mode("optimize" if active and iterating_in_progress else "fit")
+ except Exception:
+ pass
+ if active:
+ try:
+ cancel_fit_btn.disabled = False
+ except Exception:
+ pass
+ _show_cancel_button()
+ else:
+ try:
+ cancel_fit_btn.disabled = True
+ except Exception:
+ pass
+ _hide_cancel_button()
+
+ # Explicit helpers to force show/hide independent of thread state.
+ # These provide a deterministic UI state when fits/iterations start or end,
+ # avoiding races where the thread reference may still appear alive briefly.
+ def _force_cancel_fit_shown():
+ try:
+ _set_cancel_button_mode("optimize" if iterating_in_progress else "fit")
+ except Exception:
+ pass
+ try:
+ cancel_fit_btn.disabled = False
+ except Exception:
+ pass
+ _show_cancel_button()
+
+ def _force_cancel_fit_hidden():
+ # Do not hide while an iteration is active or visibility frozen
+ try:
+ if iterating_in_progress or cancel_fit_btn_frozen:
+ return
+ except Exception:
+ pass
+ try:
+ _set_cancel_button_mode("fit")
+ except Exception:
+ pass
+ try:
+ cancel_fit_btn.disabled = True
+ except Exception:
+ pass
+ _hide_cancel_button()
+
+ # hide action buttons initially
+ _hide(accept_new_peaks_btn)
+ _hide(redo_new_peaks_btn)
+ _hide(cancel_new_peaks_btn)
+ _hide_cancel_button()
+
+ def _clear_add_peak_shapes():
+ # Remove only our temporary marker shapes
+ try:
+ shapes = list(getattr(fig.layout, "shapes", ()))
+ shapes = [
+ s for s in shapes if getattr(s, "name", None) != "add_peak_marker"
+ ]
+ fig.layout.shapes = tuple(shapes)
+ except Exception:
+ try:
+ # When shapes are plain dicts
+ shapes = list(getattr(fig.layout, "shapes", ()))
+ new_shapes = []
+ for s in shapes:
+ try:
+ if s.get("name") != "add_peak_marker":
+ new_shapes.append(s)
+ except Exception:
+ new_shapes.append(s)
+ fig.layout.shapes = tuple(new_shapes)
+ except Exception:
+ pass
+
+ # Click handler for adding peaks when in adding mode (desktop / non-Colab)
+ def _on_data_click(trace, points, selector):
+ # Only respond when adding mode is ON and a valid click occurred
+ try:
+ nonlocal adding_mode
+ if not adding_mode:
+ return
+ if not points or not getattr(points, "xs", None):
+ return
+ x_clicked = float(points.xs[0])
+ except Exception:
+ return
+
+ # Get current spectrum arrays
+ idx = spectrum_sel.value
+ x_arr, y_arr = _get_xy(idx)
+ if x_arr is None or y_arr is None or x_arr.size == 0:
+ _log_once("Cannot add peak: current spectrum has no normalized data.")
+ return
+
+ # Snap to nearest x
+ try:
+ nearest_i = int(np.argmin(np.abs(x_arr - x_clicked)))
+ except Exception:
+ _log_once("Could not determine nearest x for the clicked location.")
+ return
+ x_new = float(x_arr[nearest_i])
+ # Reject if within any existing visible peak's per-peak Center ± window
+ try:
+ vis_xs, _vis_ys = _get_visible_peaks(idx)
+ except Exception:
+ vis_xs = []
+ try:
+ default_win = float(PER_PEAK_DEFAULT_CENTER_WINDOW)
+ except Exception:
+ default_win = 0.0
+ try:
+ for i, cx in enumerate(vis_xs or []):
+ try:
+ w_i = float(center_window_sliders[i].value)
+ except Exception:
+ w_i = default_win
+ # Enforce minimum separation of 2× the per-peak Center ± window
+ if abs(float(cx) - float(x_new)) <= (2.0 * abs(w_i)):
+ try:
+ status_html.value = (
+ f"Rejected: {x_new:.3f} cm⁻¹ is too close to existing peak @ {cx:.3f}. "
+ f"Must be ≥ 2×(Center ± window) = {2.0*abs(w_i):.1f} cm⁻¹ away. "
+ f"Adjust selection or that peak’s Center ± window."
+ )
+ except Exception:
+ _log_once(
+ f"Rejected: {x_new:.3f} cm⁻¹ is too close to existing peak @ {cx:.3f}. "
+ f"Must be ≥ 2×(Center ± window) = {2.0*abs(w_i):.1f} cm⁻¹ away. "
+ f"Adjust selection or that peak’s Center ± window."
+ )
+ return
+ except Exception:
+ pass
+ # Enforce minimum separation between newly selected peaks as well.
+ # Use 2× the (± window) as the required center-to-center spacing.
+ try:
+ candidate_w = float(PER_PEAK_DEFAULT_CENTER_WINDOW)
+ except Exception:
+ candidate_w = 0.0
+ for existing_x in new_peak_xs:
+ try:
+ existing_w = float(new_peak_windows.get(existing_x, candidate_w))
+ except Exception:
+ existing_w = candidate_w
+ required_sep = 2.0 * max(abs(existing_w), abs(candidate_w))
+ if abs(existing_x - x_new) <= required_sep:
+ try:
+ status_html.value = (
+ f"Rejected: {x_new:.3f} cm⁻¹ is "
+ f"too close to another selected peak ({existing_x:.3f}). "
+ f"Must be ≥ {required_sep:.2f} cm⁻¹ away (2× window). "
+ f"Tip: reduce the per-peak Center ± slider if you need peaks closer."
+ )
+ except Exception:
+ _log_once(
+ f"Rejected: {x_new:.3f} cm⁻¹ is too close to another selected peak "
+ f"({existing_x:.3f}). Must be ≥ {required_sep:.2f} cm⁻¹ away (2× window). "
+ f"Tip: reduce the per-peak Center ± slider if you need peaks closer."
+ )
+ return
+ # Compute an effective session window so the new peak's window won't cover existing peaks
+ try:
+ xs_existing, _ys_existing = _get_peaks(idx)
+ except Exception:
+ xs_existing = []
+ try:
+ if xs_existing:
+ min_dist = min(abs(float(xe) - x_new) for xe in xs_existing)
+ else:
+ min_dist = float('inf')
+ except Exception:
+ min_dist = float('inf')
+ try:
+ eff_window = float(PER_PEAK_DEFAULT_CENTER_WINDOW)
+ if np.isfinite(min_dist):
+ eff_window = min(eff_window, max(0.0, float(min_dist) - float(SESSION_WINDOW_MARGIN)))
+ except Exception:
+ eff_window = float(PER_PEAK_DEFAULT_CENTER_WINDOW)
+ try:
+ new_peak_windows[x_new] = float(eff_window)
+ except Exception:
+ pass
+ # Record and draw a vertical line marker
+ new_peak_xs.append(x_new)
+ y_min = float(np.nanmin(y_arr))
+ y_max = float(np.nanmax(y_arr))
+ try:
+ fig.add_shape(
+ dict(
+ type="line",
+ x0=x_new,
+ x1=x_new,
+ y0=y_min,
+ y1=y_max,
+ line=dict(color="#ff7f0e", dash="dot", width=1.5),
+ name="add_peak_marker",
+ )
+ )
+ except Exception:
+ pass
+ _log_once(
+ f"Selected new peak at x = {x_new:.3f} cm⁻¹. Click more points, or 'Accept "
+ f"new peaks'."
+ )
+
+ # Register click handler only outside Colab; Colab uses slider-based fallback
+ try:
+ if not _IN_COLAB:
+ fig.data[0].on_click(_on_data_click)
+ except Exception:
+ pass
+
+ def _get_xy(row_idx):
+ r = FTIR_DataFrame.loc[row_idx]
+ x = _parse_seq(r.get("X-Axis"))
+ y = _parse_seq(r.get("Normalized and Corrected Data"))
+ if x is None or y is None:
+ return None, None
+ try:
+ x_arr = np.asarray(x, dtype=float)
+ y_arr = np.asarray(y, dtype=float)
+ except Exception:
+ return None, None
+ if x_arr.ndim != 1 or y_arr.ndim != 1 or x_arr.shape[0] != y_arr.shape[0]:
+ return None, None
+ return x_arr, y_arr
+
+ def _get_peaks(row_idx):
+ # Read peaks solely from DataFrame.
+ r = FTIR_DataFrame.loc[row_idx]
+ xs = _parse_seq(r.get("Peak Wavenumbers"))
+ ys = _parse_seq(r.get("Peak Absorbances"))
+ if xs is None or ys is None:
+ return [], []
+ try:
+ xs = list(xs)
+ ys = list(ys)
+ except Exception:
+ return [], []
+ if len(xs) != len(ys):
+ return [], []
+ # Sort peaks by wavenumber (ascending)
+ try:
+ pairs = sorted(zip(xs, ys), key=lambda t: float(t[0]))
+ xs_sorted, ys_sorted = [list(t) for t in zip(*pairs)] if pairs else ([], [])
+ return xs_sorted, ys_sorted
+ except Exception:
+ return xs, ys
+
+ def _current_fit_range():
+ try:
+ lo, hi = fit_range.value
+ return float(min(lo, hi)), float(max(lo, hi))
+ except Exception:
+ return xmin, xmax
+ # Multi-range support helpers
+ def _current_fit_ranges():
+ """Return list of active (lo, hi) ranges from dynamic slider list."""
+ ranges = []
+ for sl in range_sliders:
+ try:
+ lo, hi = sl.value
+ ranges.append((float(min(lo, hi)), float(max(lo, hi))))
+ except Exception:
+ continue
+ if not ranges:
+ ranges.append((xmin, xmax))
+ return ranges
+ def _overall_fit_span():
+ rs = _current_fit_ranges()
+ lows = [r[0] for r in rs]
+ highs = [r[1] for r in rs]
+ return (float(min(lows)), float(max(highs)))
+
+ def _get_visible_peaks(row_idx):
+ xs, ys = _get_peaks(row_idx)
+ if not xs:
+ return [], []
+ ranges = _current_fit_ranges() if ' _current_fit_ranges' in globals() or True else [(lo, hi)]
+ xs_f = []
+ ys_f = []
+ for cx, cy in zip(xs, ys):
+ try:
+ cxv = float(cx)
+ except Exception:
+ continue
+ if any(lo <= cxv <= hi for lo, hi in ranges):
+ xs_f.append(cxv)
+ try:
+ ys_f.append(float(cy))
+ except Exception:
+ ys_f.append(float("nan"))
+ return xs_f, ys_f
+
+ # Visual indicator of the current Fit X-range on the plot
+ def _update_fit_range_indicator():
+ try:
+ idx = spectrum_sel.value
+ except Exception:
+ return
+ x_arr, y_arr = _get_xy(idx)
+ if x_arr is None or y_arr is None or x_arr.size == 0:
+ return
+ try:
+ ranges = _current_fit_ranges()
+ y0_min = float(np.nanmin(y_arr))
+ y0_max = float(np.nanmax(y_arr))
+ except Exception:
+ return
+ rects = []
+ for ridx, (lo, hi) in enumerate(ranges):
+ rects.append(dict(
+ type="rect",
+ x0=float(min(lo, hi)),
+ x1=float(max(lo, hi)),
+ y0=y0_min,
+ y1=y0_max,
+ fillcolor="rgba(0,120,215,0.12)",
+ line=dict(color="rgba(0,120,215,0.6)", width=1),
+ layer="below",
+ name=f"fit_range_rect_{ridx}",
+ ))
+ try:
+ shapes = list(getattr(fig.layout, "shapes", ()))
+ new_shapes = []
+ for s in shapes:
+ try:
+ # Skip any prior fit range shape; keep others
+ # (e.g., add_peak_marker)
+ nm = getattr(s, "name", None)
+ except Exception:
+ nm = None
+ if nm is None:
+ try:
+ nm = s.get("name")
+ except Exception:
+ nm = None
+ if nm and nm.startswith("fit_range_rect"):
+ continue
+ new_shapes.append(s)
+ new_shapes.extend(rects)
+ fig.layout.shapes = tuple(new_shapes)
+ except Exception:
+ # Best-effort; ignore if shapes unavailable
+ pass
+
+ def _refresh_peak_control_widgets(row_idx):
+ """Refresh peak parameter widgets for the given spectrum, reusing cached controls when ranges change."""
+ nonlocal alpha_sliders, include_checkboxes, center_sliders, sigma_sliders, amplitude_sliders, center_window_sliders
+ nonlocal amplitude_mode_toggles, center_mode_toggles, sigma_mode_toggles
+ nonlocal lock_alpha_checkboxes, lock_center_checkboxes, lock_sigma_checkboxes
+ nonlocal peak_center_state_by_idx, previous_in_range_indices
+ nonlocal center_slider_peak_indices
+ # Build controls only for peaks within any active Fit X-range (lazy creation).
+ # Out-of-range peak widgets (headers) are created only when the excluded toggle is enabled.
+ try:
+ # Show transient building message while list is (re)constructed.
+ peak_controls_box.children = [
+ widgets.HTML("Building Peak List . . .")
+ ]
+ except Exception:
+ pass
+ peaks_x_all, peaks_y_all = _get_peaks(row_idx)
+ state_for_spectrum = peak_center_state_by_idx.setdefault(row_idx, {})
+ valid_indices = set(range(len(peaks_x_all)))
+ for _idx_key in list(state_for_spectrum.keys()):
+ if _idx_key not in valid_indices:
+ try:
+ del state_for_spectrum[_idx_key]
+ except Exception:
+ pass
+ for _idx_local, _cx_val in enumerate(peaks_x_all):
+ _set_peak_initial_center(row_idx, _idx_local, _cx_val)
+ try:
+ original_peak_centers[:] = [float(_cx) for _cx in peaks_x_all]
+ except Exception:
+ original_peak_centers[:] = list(peaks_x_all) if peaks_x_all else []
+ alpha_sliders = []
+ include_checkboxes = []
+ center_sliders = []
+ sigma_sliders = []
+ amplitude_sliders = []
+ center_window_sliders = []
+ amplitude_mode_toggles = []
+ center_mode_toggles = []
+ sigma_mode_toggles = []
+ lock_alpha_checkboxes = []
+ lock_center_checkboxes = []
+ lock_sigma_checkboxes = []
+ children = []
+ if not peaks_x_all:
+ peak_controls_box.children = [
+ widgets.HTML(
+ "No peaks found. Run find_peak_info first."
+ )
+ ]
+ return
+ try:
+ active_ranges = _current_fit_ranges()
+ except Exception:
+ active_ranges = [(float("-inf"), float("inf"))]
+ # Do not restore per-spectrum/group-level settings; start from defaults
+ saved_alphas = None
+ saved_includes = None
+ saved_center = None
+ saved_sigma = None
+ saved_amplitude = None
+ saved_modes = {'amplitude': None, 'center': None, 'sigma': None}
+ saved_center_window = None
+ saved_locks = {'alpha': None, 'center': None, 'sigma': None}
+ if saved_center:
+ try:
+ for _idx_local, _val in enumerate(saved_center):
+ if _idx_local in valid_indices:
+ _set_peak_user_center(row_idx, _idx_local, _val)
+ except Exception:
+ pass
+ # No group-level fallbacks; rely on defaults each rebuild
+ if not isinstance(saved_locks, dict):
+ saved_locks = {'alpha': None, 'center': None, 'sigma': None}
+ included_boxes = [] # will be used only for full rebuild path
+ excluded_boxes = []
+ # Cache for previously built in-range peak widgets so we can reuse them on subsequent rebuilds
+ # (avoids re-instantiating many sliders when only the Fit X-ranges changed).
+ # Persist across calls inside the closure scope.
+ global peak_box_cache
+ if not isinstance(peak_box_cache, dict):
+ peak_box_cache = {}
+ # Never reuse cached widget objects across different spectra.
+ nonlocal cache_owner_idx
+ try:
+ if cache_owner_idx != row_idx:
+ peak_box_cache.clear()
+ cache_owner_idx = row_idx
+ previous_in_range_indices = set()
+ except Exception:
+ cache_owner_idx = row_idx
+
+ # --- Parameter explanations for the toggle ---
+ param_details_text = (
+ "α: Inversely relates to the steepness of the peak. Fractional composition of Gaussian (0) and Lorentzian (1) components.\n"
+ "μ: Center position of the peak (wavenumber). Window mode varies μ within ± the window; Exact mode fixes μ at the slider value.\n"
+ "A: Relates to the height of the peak.\n"
+ "σ: Relates to the width of the peak. The FWHM is 2σ.\n"
+ )
+
+ def _make_param_details_row():
+ toggle = widgets.ToggleButton(
+ value=False,
+ description="Parameter Details",
+ button_style="info",
+ icon="chevron-down",
+ layout=widgets.Layout(width="180px", margin="0 0 0 10px"),
+ tooltip="Show/hide parameter explanations"
+ )
+ details = widgets.HTML(
+ value=f"{param_details_text}",
+ layout=widgets.Layout(margin="0 0 0 10px", border="1px solid #bbb", padding="6px", display="none", background="#f8f8f8")
+ )
+ def _on_toggle(change):
+ if change.get("name") == "value":
+ show = bool(change.get("new"))
+ details.layout.display = "block" if show else "none"
+ try:
+ toggle.icon = "chevron-up" if show else "chevron-down"
+ except Exception:
+ pass
+ toggle.observe(_on_toggle, names="value")
+ return widgets.HBox([toggle, details], layout=widgets.Layout(margin="4px 0 4px 0"))
+
+ # Build per-peak controls as before, but without per-row info buttons
+ # Reset tracking lists for headers/original centers and capture current active ranges
+ peak_label_widgets.clear()
+ original_peak_centers.clear()
+ last_active_ranges = list(active_ranges)
+ # Vectorized in-range computation for performance (avoids per-peak Python loops)
+ try:
+ import numpy as _np
+ cx_array = _np.asarray(peaks_x_all, dtype=float)
+ in_range_mask = _np.zeros_like(cx_array, dtype=bool)
+ for _lo, _hi in active_ranges:
+ try:
+ lo_v = float(min(_lo, _hi))
+ hi_v = float(max(_lo, _hi))
+ in_range_mask |= (cx_array >= lo_v) & (cx_array <= hi_v)
+ except Exception:
+ pass
+ except Exception:
+ # Fallback: compute naïvely if numpy not available
+ in_range_mask = []
+ for _cx in peaks_x_all:
+ try:
+ _cxv = float(_cx)
+ in_range_mask.append(any(lo <= _cxv <= hi for lo, hi in active_ranges))
+ except Exception:
+ in_range_mask.append(False)
+
+ excluded_peaks_list = []
+
+ # --- Diff removal path -------------------------------------------------
+ # If we have a cache of all previously built peak boxes and the total count of peaks
+ # did not change, we can perform an in-place diff update instead of a full rebuild.
+ diff_applicable = False
+ if isinstance(peak_box_cache, dict) and len(peak_box_cache) == len(peaks_x_all):
+ diff_applicable = True
+
+ # Compute new in-range set early for diff logic
+ new_in_range_set = {i for i, flag in enumerate(in_range_mask) if bool(flag)}
+
+ if diff_applicable and previous_in_range_indices:
+ removed = previous_in_range_indices - new_in_range_set
+ added = new_in_range_set - previous_in_range_indices
+ unchanged = previous_in_range_indices & new_in_range_set
+ # If no changes, simply update summary and return fast
+ if not removed and not added:
+ try:
+ # Update excluded list text (unchanged except counts)
+ excluded_peaks_list = [
+ (i+1, float(peaks_x_all[i])) for i in range(len(peaks_x_all)) if i not in new_in_range_set
+ ]
+ if excluded_peaks_list:
+ excluded_lines = [f"Peak {num} @ {val:.1f} cm⁻¹" for num, val in excluded_peaks_list]
+ excluded_text = "
".join(excluded_lines)
+ excluded_peaks_html.value = (
+ f"Excluded Peaks:{excluded_text}
"
+ )
+ else:
+ excluded_peaks_html.value = "Excluded Peaks: None"
+ summary_html = widgets.HTML(
+ f"In-range peaks: {len(new_in_range_set)} / Total: {len(peaks_x_all)}"
+ )
+ # Preserve existing parameter details row (first child) and accordion
+ try:
+ existing_children = list(peak_controls_box.children)
+ if existing_children and isinstance(existing_children[0], widgets.HBox):
+ param_row = existing_children[0]
+ else:
+ param_row = _make_param_details_row()
+ # Reconstruct children minimally (param row, included header, accordion, excluded html)
+ peak_controls_box.children = [
+ param_row,
+ widgets.HTML("Included Peaks:"),
+ peak_accordion,
+ excluded_peaks_html,
+ ]
+ # Swap summary HTML into param row if it contains a summary placeholder
+ # (We assume param_row contains toggle + details; we append summary alongside)
+ try:
+ if len(param_row.children) == 2:
+ param_row.children = (param_row.children[0], param_row.children[1], summary_html)
+ except Exception:
+ pass
+ except Exception:
+ pass
+ except Exception:
+ pass
+ previous_in_range_indices = new_in_range_set
+ # Rebuild tracking lists from cache for unchanged peaks
+ alpha_sliders = []
+ include_checkboxes = []
+ center_sliders = []
+ center_slider_peak_indices = []
+ sigma_sliders = []
+ amplitude_sliders = []
+ center_window_sliders = []
+ amplitude_mode_toggles = []
+ center_mode_toggles = []
+ sigma_mode_toggles = []
+ for i in sorted(new_in_range_set):
+ try:
+ w = peak_box_cache[i]
+ include_checkboxes.append(w['include'])
+ alpha_sliders.append(w['alpha'])
+ center_sliders.append(w['center'])
+ center_slider_peak_indices.append(i)
+ sigma_sliders.append(w['sigma'])
+ amplitude_sliders.append(w['amplitude'])
+ center_window_sliders.append(w['center_window'])
+ amplitude_mode_toggles.append(w['amp_mode'])
+ center_mode_toggles.append(w['center_mode'])
+ sigma_mode_toggles.append(w['sigma_mode'])
+ # Attach canonical index to include checkbox for later mapping
+ try:
+ setattr(include_checkboxes[-1], '_original_idx', i)
+ except Exception:
+ pass
+ except Exception:
+ pass
+ try:
+ for _idx_in_range in sorted(new_in_range_set):
+ _update_peak_toggle_label(_idx_in_range, spectrum_idx=row_idx)
+ except Exception:
+ pass
+ return # No UI rebuild required
+
+ # Process removals: hide or remove boxes
+ try:
+ current_children = list(getattr(peak_accordion, 'children', ()))
+ except Exception:
+ current_children = []
+ # Map box -> peak index for quick removal
+ inv_map = {}
+ for idx in previous_in_range_indices:
+ try:
+ inv_map[peak_box_cache[idx]['box']] = idx
+ except Exception:
+ pass
+ # Remove boxes for peaks leaving range
+ if removed:
+ new_children = []
+ for box in current_children:
+ idx = inv_map.get(box, None)
+ if idx is not None and idx in removed:
+ # Move to excluded (we just drop from included; excluded list is text-only)
+ try:
+ box.layout.display = 'none'
+ except Exception:
+ pass
+ continue
+ new_children.append(box)
+ try:
+ peak_accordion.children = tuple(new_children)
+ except Exception:
+ pass
+ # Helper to rebuild tracking lists (placeholders and materialized widgets alike)
+ def _refresh_slider_lists():
+ nonlocal alpha_sliders, include_checkboxes, center_sliders, sigma_sliders, amplitude_sliders, center_window_sliders
+ nonlocal amplitude_mode_toggles, center_mode_toggles, sigma_mode_toggles
+ nonlocal center_slider_peak_indices
+ alpha_sliders = []
+ include_checkboxes = []
+ center_sliders = []
+ center_slider_peak_indices = []
+ sigma_sliders = []
+ amplitude_sliders = []
+ center_window_sliders = []
+ amplitude_mode_toggles = []
+ center_mode_toggles = []
+ sigma_mode_toggles = []
+ for _i in sorted(new_in_range_set):
+ try:
+ w = peak_box_cache[_i]
+ include_checkboxes.append(w['include'])
+ alpha_sliders.append(w['alpha'])
+ center_sliders.append(w['center'])
+ center_slider_peak_indices.append(_i)
+ sigma_sliders.append(w['sigma'])
+ amplitude_sliders.append(w['amplitude'])
+ center_window_sliders.append(w['center_window'])
+ amplitude_mode_toggles.append(w['amp_mode'])
+ center_mode_toggles.append(w['center_mode'])
+ sigma_mode_toggles.append(w['sigma_mode'])
+ try:
+ setattr(include_checkboxes[-1], '_original_idx', _i)
+ except Exception:
+ pass
+ except Exception:
+ pass
+ # Expose helper so module-level utilities (e.g., accordion scans) can refresh lists.
+ globals()['_refresh_slider_lists'] = _refresh_slider_lists
+
+ # Materialization function builds full controls for a single peak on demand
+ def _materialize_peak(peak_idx: int, force: bool = False):
+ # Build full control set for a peak. When lazy mode has been disabled
+ # (LAZY_PEAK_WIDGETS False) we allow forced materialization for eager
+ # fallback by passing force=True.
+ global LAZY_PEAK_WIDGETS
+ if (not LAZY_PEAK_WIDGETS) and (not force):
+ return
+ try:
+ cache_entry = peak_box_cache.get(peak_idx)
+ if not cache_entry or cache_entry.get('materialized'):
+ return # Already built or missing
+ # Heavy build replicating original per-peak construction logic
+ cx = peaks_x_all[peak_idx]; cy = peaks_y_all[peak_idx]
+ original_center_val_local = float(cx)
+ default_bound = float(PER_PEAK_DEFAULT_CENTER_WINDOW)
+ min_cwin = 0.5
+ # Recover saved values if present
+ w_saved = default_bound
+ if saved_center_window is not None and peak_idx < len(saved_center_window):
+ try:
+ candidate = float(saved_center_window[peak_idx])
+ if np.isfinite(candidate) and candidate > 0.0:
+ w_saved = candidate
+ except Exception:
+ pass
+ center_min, center_max = _overall_fit_span()
+ center_val_local = float(cx)
+ if saved_center is not None and peak_idx < len(saved_center):
+ try:
+ center_val_local = float(saved_center[peak_idx])
+ except Exception:
+ pass
+ center_slider = widgets.FloatSlider(
+ value=center_val_local, min=center_min, max=center_max, step=0.1,
+ description="μ (cm⁻¹)", continuous_update=False, style={"description_width": "auto"},
+ readout_format=".1f", layout=widgets.Layout(width="220px")
+ )
+ _set_peak_user_center(row_idx, peak_idx, center_val_local)
+ peak_state_local = peak_center_state_by_idx.get(row_idx, {}).get(peak_idx, {})
+ initial_center_val = peak_state_local.get('initial', center_val_local)
+ center_window_slider = widgets.FloatSlider(
+ value=w_saved, min=min_cwin, max=max(default_bound*2.0, 1.0), step=0.5,
+ description="Window ± (cm⁻¹)", continuous_update=False, style={"description_width": "auto"},
+ readout_format=".1f", layout=widgets.Layout(width="220px")
+ )
+ sigma_val = float(PER_PEAK_DEFAULT_SIGMA)
+ if saved_sigma is not None and peak_idx < len(saved_sigma):
+ try:
+ tmp = float(saved_sigma[peak_idx])
+ if np.isfinite(tmp):
+ sigma_val = tmp
+ except Exception:
+ pass
+ sigma_slider = widgets.FloatSlider(
+ value=sigma_val, min=1.0, max=100.0, step=0.5, description="σ (cm⁻¹)",
+ continuous_update=False, style={"description_width": "auto"}, readout_format=".1f",
+ layout=widgets.Layout(width="220px")
+ )
+ amp_default = abs(float(cy)) * max(1.0, float(PER_PEAK_DEFAULT_SIGMA))
+ amp_val_local = amp_default
+ if saved_amplitude is not None and peak_idx < len(saved_amplitude):
+ try:
+ amp_candidate = float(saved_amplitude[peak_idx])
+ if np.isfinite(amp_candidate) and amp_candidate >= 0.0:
+ amp_val_local = amp_candidate
+ except Exception:
+ pass
+ amplitude_slider = widgets.FloatSlider(
+ value=amp_val_local, min=0.0, max=max(amp_default*5.0, amp_val_local, 1.0),
+ step=max(amp_default*0.01, 0.01), description="A", continuous_update=False,
+ style={"description_width": "auto"}, readout_format=".3f", layout=widgets.Layout(width="220px")
+ )
+ alpha_val_local = DEFAULT_ALPHA
+ if saved_alphas is not None and peak_idx < len(saved_alphas):
+ try:
+ a_candidate = float(saved_alphas[peak_idx])
+ if 0.0 <= a_candidate <= 1.0:
+ alpha_val_local = a_candidate
+ except Exception:
+ pass
+ alpha_slider = widgets.FloatSlider(
+ value=alpha_val_local, min=0.0, max=1.0, step=0.01, description="α",
+ continuous_update=False, readout_format=".2f", style={"description_width": "auto"},
+ layout=widgets.Layout(width="220px")
+ )
+ include_val_local = True
+ if saved_includes is not None and peak_idx < len(saved_includes):
+ try:
+ include_val_local = bool(saved_includes[peak_idx])
+ except Exception:
+ pass
+ include_checkbox = widgets.Checkbox(value=include_val_local, description="Include peak in Fit", indent=False,
+ layout=widgets.Layout(width="200px"))
+ try:
+ setattr(include_checkbox, '_original_idx', peak_idx)
+ except Exception:
+ pass
+ # Restore saved modes if available
+ amp_mode_val_local = 'Auto'
+ center_mode_val_local = CENTER_MODE_WINDOW
+ sigma_mode_val_local = 'Auto'
+ if saved_modes and isinstance(saved_modes.get('amplitude'), list) and peak_idx < len(saved_modes.get('amplitude')):
+ amp_mode_val_local = saved_modes['amplitude'][peak_idx]
+ if saved_modes and isinstance(saved_modes.get('center'), list) and peak_idx < len(saved_modes.get('center')):
+ center_mode_val_local = _normalize_center_mode_value(saved_modes['center'][peak_idx])
+ if saved_modes and isinstance(saved_modes.get('sigma'), list) and peak_idx < len(saved_modes.get('sigma')):
+ sigma_mode_val_local = saved_modes['sigma'][peak_idx]
+ amp_mode_toggle = widgets.Dropdown(options=[('Auto','Auto'),('Manual','Manual')], value=amp_mode_val_local, layout=widgets.Layout(width='110px'), style={'description_width':'initial'}, description='')
+ center_mode_val_local = _normalize_center_mode_value(center_mode_val_local)
+ center_mode_toggle = widgets.Dropdown(options=CENTER_MODE_OPTIONS, value=center_mode_val_local, layout=widgets.Layout(width='110px'), style={'description_width':'initial'}, description='')
+ sigma_mode_toggle = widgets.Dropdown(options=[('Auto','Auto'),('Manual','Manual')], value=sigma_mode_val_local, layout=widgets.Layout(width='110px'), style={'description_width':'initial'}, description='')
+
+ # Attach observers (subset copied from original logic)
+ include_checkbox.observe(_on_include_toggle, names="value")
+ alpha_slider.observe(_on_alpha_change, names="value")
+ _bind_center_slider(center_slider, peak_idx, row_idx)
+ amplitude_slider.observe(_on_center_sigma_change, names="value")
+ center_window_slider.observe(_on_center_sigma_change, names="value")
+ def _on_sigma_change(change, idx_local=peak_idx):
+ # No persistence across spectra; simply snapshot (no-op) to maintain flow
+ if sigma_mode_toggle.value == 'Manual':
+ _snapshot_current_controls()
+ sigma_slider.observe(_on_sigma_change, names="value")
+
+ # Build layout inside details box
+ details_box = cache_entry['details']
+ try:
+ # Separate labels to keep all controls horizontal; remove slider descriptions (except alpha) to prevent vertical stacking.
+ amplitude_slider.description = ''
+ center_slider.description = ''
+ center_window_slider.description = '' # we will render a side label instead
+ sigma_slider.description = ''
+ alpha_slider.description = '' # remove inline description per request
+ # Short widths for horizontal fit
+ amplitude_slider.layout.width = '160px'
+ center_slider.layout.width = '160px'
+ center_window_slider.layout.width = '160px'
+ sigma_slider.layout.width = '160px'
+ alpha_slider.layout.width = '160px'
+ # Capture original values for reset functionality
+ amplitude_slider._original_value = amplitude_slider.value # type: ignore[attr-defined]
+ center_slider._original_value = center_slider.value # type: ignore[attr-defined]
+ center_window_slider._original_value = center_window_slider.value # type: ignore[attr-defined]
+ sigma_slider._original_value = sigma_slider.value # type: ignore[attr-defined]
+ alpha_slider._original_value = alpha_slider.value # type: ignore[attr-defined]
+ # Build reset buttons
+ def _mk_reset(target, default_cb=None):
+ btn = widgets.Button(description='Reset', layout=widgets.Layout(width='58px'))
+ def _on_click(_):
+ try:
+ if callable(default_cb):
+ candidate = default_cb()
+ if candidate is not None:
+ target.value = candidate
+ return
+ orig = getattr(target, '_original_value', None)
+ if orig is not None:
+ target.value = orig
+ except Exception:
+ pass
+ btn.on_click(_on_click)
+ return btn
+ amplitude_reset = _mk_reset(amplitude_slider)
+ def _center_reset_value():
+ try:
+ mode_val = center_mode_toggle.value
+ except Exception:
+ mode_val = CENTER_MODE_WINDOW
+ try:
+ base_val = float(initial_center_val)
+ except Exception:
+ base_val = initial_center_val
+ if mode_val == CENTER_MODE_EXACT:
+ return base_val
+ orig_local = getattr(center_slider, '_original_value', None)
+ return orig_local if orig_local is not None else base_val
+ center_reset = _mk_reset(center_slider, default_cb=_center_reset_value)
+ center_window_reset = _mk_reset(center_window_slider)
+ sigma_reset = _mk_reset(sigma_slider)
+ alpha_reset = _mk_reset(alpha_slider)
+ # Common row layout: horizontal flex, visible overflow, generous height to avoid scroll
+ _row_layout = widgets.Layout(
+ display='flex', flex_flow='row nowrap', align_items='center',
+ gap='10px', overflow='visible', min_height='42px'
+ )
+ include_row = widgets.HBox([include_checkbox], layout=_row_layout)
+ # Restore row labels for legibility
+ # Window label separate to avoid vertical stacking; mu label separated for mode visibility logic
+ mu_label = widgets.HTML('μ')
+ # Make window label non-bold for reduced visual weight
+ window_label = widgets.HTML('Window ± (cm⁻¹)')
+ mu_row = widgets.HBox([
+ mu_label, center_mode_toggle, center_slider, center_reset, window_label, center_window_slider, center_window_reset
+ ], layout=_row_layout)
+ amplitude_label = widgets.HTML('A')
+ amplitude_row = widgets.HBox([
+ amplitude_label, amp_mode_toggle, amplitude_slider, amplitude_reset
+ ], layout=_row_layout)
+ sigma_label = widgets.HTML('σ')
+ sigma_row = widgets.HBox([
+ sigma_label, sigma_mode_toggle, sigma_slider, sigma_reset
+ ], layout=_row_layout)
+ alpha_row = widgets.HBox([
+ widgets.HTML('α'), alpha_slider, alpha_reset
+ ], layout=_row_layout)
+ # Ensure container overflow does not force internal scrolling
+ try:
+ details_box.layout.overflow = 'visible'
+ except Exception:
+ pass
+
+ def _sync_mode_visibility(*_):
+ # Amplitude row: show label always; hide slider/reset in Auto
+ try:
+ if amp_mode_toggle.value == 'Auto':
+ amplitude_slider.layout.display = 'none'
+ amplitude_reset.layout.display = 'none'
+ else:
+ amplitude_slider.layout.display = 'block'
+ amplitude_reset.layout.display = 'block'
+ amplitude_label.layout.display = 'block'
+ except Exception:
+ pass
+ # Center/window row: label always; toggle sliders per mode
+ try:
+ center_slider.layout.display = 'block'
+ center_reset.layout.display = 'block'
+ if center_mode_toggle.value == CENTER_MODE_WINDOW:
+ center_window_slider.layout.display = 'block'
+ center_window_reset.layout.display = 'block'
+ window_label.layout.display = 'block'
+ else:
+ center_window_slider.layout.display = 'none'
+ center_window_reset.layout.display = 'none'
+ window_label.layout.display = 'none'
+ mu_label.layout.display = 'block'
+ except Exception:
+ pass
+ # Sigma row: show label always; hide slider/reset in Auto
+ try:
+ if sigma_mode_toggle.value == 'Auto':
+ sigma_slider.layout.display = 'none'
+ sigma_reset.layout.display = 'none'
+ else:
+ sigma_slider.layout.display = 'block'
+ sigma_reset.layout.display = 'block'
+ sigma_label.layout.display = 'block'
+ except Exception:
+ pass
+ try:
+ amp_mode_toggle.observe(_sync_mode_visibility, names='value')
+ center_mode_toggle.observe(_sync_mode_visibility, names='value')
+ sigma_mode_toggle.observe(_sync_mode_visibility, names='value')
+ except Exception:
+ pass
+ _sync_mode_visibility()
+ details_box.children = [include_row, alpha_row, mu_row, amplitude_row, sigma_row]
+ except Exception:
+ details_box.children = [alpha_slider, center_slider, center_window_slider, amplitude_slider, sigma_slider]
+
+ # Update cache entry with real widgets
+ cache_entry.update({
+ 'include': include_checkbox,
+ 'alpha': alpha_slider,
+ 'center': center_slider,
+ 'sigma': sigma_slider,
+ 'amplitude': amplitude_slider,
+ 'center_window': center_window_slider,
+ 'amp_mode': amp_mode_toggle,
+ 'center_mode': center_mode_toggle,
+ 'sigma_mode': sigma_mode_toggle,
+ 'materialized': True,
+ })
+ _refresh_slider_lists()
+ except Exception as e:
+ # Capture detailed traceback for diagnostics when debug enabled
+ try:
+ import traceback
+ _DECONV_DEBUG_ERRORS.append(traceback.format_exc(limit=12))
+ except Exception:
+ pass
+ _lazy_debug(f"Materialization failed for peak {peak_idx}: {e.__class__.__name__}: {e}")
+ try:
+ status_html.value = "Lazy peak build failed; reverting to eager mode. Set DECONV_DEBUG=True for details."
+ except Exception:
+ pass
+ LAZY_PEAK_WIDGETS = False
+ return
+
+ # Add boxes for peaks newly entering range
+ if added:
+ for idx in sorted(added):
+ try:
+ # Reuse existing cached widgets if previously built; make visible
+ if idx in peak_box_cache:
+ entry = peak_box_cache.get(idx, {})
+ box = entry.get('box')
+ if box is not None:
+ try:
+ setattr(box, '_peak_idx', idx)
+ except Exception:
+ pass
+ try:
+ current_children = list(getattr(peak_accordion, 'children', ()))
+ except Exception:
+ current_children = []
+ if box not in current_children:
+ insert_pos = 0
+ for child in current_children:
+ try:
+ child_idx = getattr(child, '_peak_idx', None)
+ except Exception:
+ child_idx = None
+ if child_idx is None and hasattr(child, 'children') and child.children:
+ try:
+ desc = getattr(child.children[0], 'description', '')
+ if desc.startswith('Peak '):
+ num_part = desc.split(' ')[1]
+ child_idx = int(num_part) - 1
+ except Exception:
+ child_idx = None
+ if child_idx is not None and child_idx < idx:
+ insert_pos += 1
+ try:
+ current_children.insert(insert_pos, box)
+ peak_accordion.children = tuple(current_children)
+ except Exception:
+ pass
+ try:
+ box.layout.display = ''
+ except Exception:
+ pass
+ _update_peak_toggle_label(idx, spectrum_idx=row_idx)
+ continue
+ # Minimal lazy build: only toggle + empty details container; placeholders for controls
+ cx = peaks_x_all[idx]
+ original_center_val_local = float(cx)
+ details = widgets.VBox([]); details.layout.display = 'none'
+ toggle = widgets.ToggleButton(value=False, description=f"Peak {idx+1} @ {original_center_val_local:.1f} → {original_center_val_local:.1f} cm⁻¹", icon='chevron-down', layout=widgets.Layout(width='auto'))
+ def _on_toggle_local(change, _t=toggle, _d=details, _idx=idx):
+ if change.get('name') == 'value':
+ show = bool(change.get('new'))
+ _d.layout.display = 'block' if show else 'none'
+ try:
+ _t.icon = 'chevron-up' if show else 'chevron-down'
+ except Exception:
+ pass
+ # Lazy materialization trigger
+ if show:
+ try:
+ # Try lazy first (may raise). If lazy disabled, force eager build.
+ if LAZY_PEAK_WIDGETS:
+ _materialize_peak(_idx)
+ else:
+ _materialize_peak(_idx, force=True)
+ except Exception:
+ # Capture traceback for diagnostics
+ try:
+ import traceback
+ global _DECONV_DEBUG_ERRORS
+ _DECONV_DEBUG_ERRORS.append(traceback.format_exc(limit=12))
+ except Exception:
+ pass
+ _lazy_debug(f"Toggle local failed for peak {_idx}")
+ try:
+ status_html.value = "Lazy materialization failed; switching to eager mode."
+ except Exception:
+ pass
+ try:
+ LAZY_PEAK_WIDGETS = False
+ except Exception:
+ pass
+ # Attempt eager materialization once after failure
+ try:
+ _materialize_peak(_idx, force=True)
+ except Exception:
+ pass
+ toggle.observe(_on_toggle_local, names='value')
+ box = widgets.VBox([toggle, details], layout=widgets.Layout(border="2.5px solid #222", margin="12px 0", padding="16px 22px", border_radius="12px", background="#2d3748"))
+ try:
+ setattr(box, '_peak_idx', idx)
+ except Exception:
+ pass
+ # Insert at correct sorted position
+ try:
+ current_children = list(getattr(peak_accordion, 'children', ()))
+ insert_pos = 0
+ # Determine insertion point by counting existing children with peak index < idx
+ for c in current_children:
+ try:
+ desc = getattr(c.children[0], 'description', '')
+ if desc.startswith('Peak '):
+ # Extract original peak number
+ num_part = desc.split(' ')[1]
+ peak_num = int(num_part)
+ # peak_num is 1-based
+ if peak_num-1 < idx:
+ insert_pos += 1
+ except Exception:
+ pass
+ current_children.insert(insert_pos, box)
+ peak_accordion.children = tuple(current_children)
+ except Exception:
+ pass
+ # Cache placeholders only if not already materialized (avoid overwriting real widgets)
+ if not (idx in peak_box_cache and peak_box_cache[idx].get('materialized')):
+ peak_box_cache[idx] = {
+ 'box': box,
+ 'toggle': toggle,
+ 'details': details,
+ 'include': _LazyPlaceholder(True),
+ 'alpha': _LazyPlaceholder(DEFAULT_ALPHA),
+ 'center': _LazyPlaceholder(float(cx)),
+ 'sigma': _LazyPlaceholder(float(PER_PEAK_DEFAULT_SIGMA)),
+ 'amplitude': _LazyPlaceholder(abs(float(peaks_y_all[idx])) * max(1.0, float(PER_PEAK_DEFAULT_SIGMA))),
+ 'center_window': _LazyPlaceholder(float(PER_PEAK_DEFAULT_CENTER_WINDOW)),
+ 'amp_mode': _LazyModePlaceholder('Auto'),
+ 'center_mode': _LazyModePlaceholder(CENTER_MODE_WINDOW),
+ 'sigma_mode': _LazyModePlaceholder('Auto'),
+ 'materialized': False,
+ }
+ _update_peak_toggle_label(idx, spectrum_idx=row_idx)
+ except Exception:
+ pass
+ # After lazy additions, refresh tracking lists (placeholders included)
+ _refresh_slider_lists()
+ # Update excluded list & summary after diff ops
+ try:
+ excluded_peaks_list = [
+ (i+1, float(peaks_x_all[i])) for i in range(len(peaks_x_all)) if i not in new_in_range_set
+ ]
+ if excluded_peaks_list:
+ excluded_lines = [f"Peak {num} @ {val:.1f} cm⁻¹" for num, val in excluded_peaks_list]
+ excluded_text = "
".join(excluded_lines)
+ excluded_peaks_html.value = (
+ f"Excluded Peaks:{excluded_text}
"
+ )
+ else:
+ excluded_peaks_html.value = "Excluded Peaks: None"
+ summary_html = widgets.HTML(
+ f"In-range peaks: {len(new_in_range_set)} / Total: {len(peaks_x_all)}"
+ )
+ # Reconstruct control box children minimally
+ try:
+ existing_children = list(peak_controls_box.children)
+ if existing_children and isinstance(existing_children[0], widgets.HBox):
+ param_row = existing_children[0]
+ else:
+ param_row = _make_param_details_row()
+ peak_controls_box.children = [
+ param_row,
+ widgets.HTML("Included Peaks:"),
+ peak_accordion,
+ excluded_peaks_html,
+ ]
+ try:
+ if len(param_row.children) == 2:
+ param_row.children = (param_row.children[0], param_row.children[1], summary_html)
+ except Exception:
+ pass
+ except Exception:
+ pass
+ except Exception:
+ pass
+ # Rebuild tracking lists from cache for new set
+ alpha_sliders = []
+ include_checkboxes = []
+ center_sliders = []
+ center_slider_peak_indices = []
+ sigma_sliders = []
+ amplitude_sliders = []
+ center_window_sliders = []
+ amplitude_mode_toggles = []
+ center_mode_toggles = []
+ sigma_mode_toggles = []
+ for i in sorted(new_in_range_set):
+ try:
+ w = peak_box_cache[i]
+ include_checkboxes.append(w['include'])
+ alpha_sliders.append(w['alpha'])
+ center_sliders.append(w['center'])
+ center_slider_peak_indices.append(i)
+ sigma_sliders.append(w['sigma'])
+ amplitude_sliders.append(w['amplitude'])
+ center_window_sliders.append(w['center_window'])
+ amplitude_mode_toggles.append(w['amp_mode'])
+ center_mode_toggles.append(w['center_mode'])
+ sigma_mode_toggles.append(w['sigma_mode'])
+ try:
+ setattr(include_checkboxes[-1], '_original_idx', i)
+ except Exception:
+ pass
+ except Exception:
+ pass
+ previous_in_range_indices = new_in_range_set
+ return # Diff path handled fully; skip full rebuild below
+
+ # --- End diff removal path; fall back to full rebuild ------------------
+ previous_in_range_indices = new_in_range_set # initialize tracking for next diff cycle
+ # Placeholder-only initial build (no heavy sliders) when diff path not available
+ included_boxes = []
+ excluded_peaks_list = []
+ for i, cx in enumerate(peaks_x_all):
+ in_range = bool(in_range_mask[i]) if i < len(in_range_mask) else False
+ original_center_val = float(cx)
+ if not in_range:
+ excluded_peaks_list.append((i+1, original_center_val))
+ continue
+ # Ensure materialization function exists even when entering fallback path
+ if '_materialize_peak' not in locals():
+ def _materialize_peak(peak_idx: int, force: bool = False):
+ global LAZY_PEAK_WIDGETS
+ if (not LAZY_PEAK_WIDGETS) and (not force):
+ return
+ try:
+ cache_entry = peak_box_cache.get(peak_idx)
+ if not cache_entry or cache_entry.get('materialized'):
+ return
+ cx_local = peaks_x_all[peak_idx]; cy_local = peaks_y_all[peak_idx]
+ original_center_val_local = float(cx_local)
+ default_bound_local = float(PER_PEAK_DEFAULT_CENTER_WINDOW)
+ min_cwin_local = 0.5
+ w_saved_local = default_bound_local
+ try:
+ if saved_center_window is not None and peak_idx < len(saved_center_window):
+ cand = float(saved_center_window[peak_idx])
+ if np.isfinite(cand) and cand > 0.0:
+ w_saved_local = cand
+ except Exception:
+ pass
+ center_min_local, center_max_local = _overall_fit_span() if ' _overall_fit_span' in globals() or '_overall_fit_span' in locals() else (float(np.nanmin(peaks_x_all)), float(np.nanmax(peaks_x_all)))
+ center_val_local = float(cx_local)
+ try:
+ if saved_center is not None and peak_idx < len(saved_center):
+ center_val_local = float(saved_center[peak_idx])
+ except Exception:
+ pass
+ center_slider = widgets.FloatSlider(value=center_val_local, min=center_min_local, max=center_max_local, step=0.1, description="μ (cm⁻¹)", continuous_update=False, style={"description_width": "auto"}, readout_format=".1f", layout=widgets.Layout(width="220px"))
+ _set_peak_user_center(row_idx, peak_idx, center_val_local)
+ peak_state_local = peak_center_state_by_idx.get(row_idx, {}).get(peak_idx, {})
+ initial_center_val = peak_state_local.get('initial', center_val_local)
+ center_window_slider = widgets.FloatSlider(value=w_saved_local, min=min_cwin_local, max=max(default_bound_local*2.0, 1.0), step=0.5, description="Window ± (cm⁻¹)", continuous_update=False, style={"description_width": "auto"}, readout_format=".1f", layout=widgets.Layout(width="220px"))
+ sigma_val_local = float(PER_PEAK_DEFAULT_SIGMA)
+ try:
+ if saved_sigma is not None and peak_idx < len(saved_sigma):
+ tmp = float(saved_sigma[peak_idx])
+ if np.isfinite(tmp):
+ sigma_val_local = tmp
+ except Exception:
+ pass
+ sigma_slider = widgets.FloatSlider(value=sigma_val_local, min=1.0, max=100.0, step=0.5, description="σ (cm⁻¹)", continuous_update=False, style={"description_width": "auto"}, readout_format=".1f", layout=widgets.Layout(width="220px"))
+ amp_default_local = abs(float(cy_local)) * max(1.0, float(PER_PEAK_DEFAULT_SIGMA))
+ amp_val_local = amp_default_local
+ try:
+ if saved_amplitude is not None and peak_idx < len(saved_amplitude):
+ cand_a = float(saved_amplitude[peak_idx])
+ if np.isfinite(cand_a) and cand_a >= 0.0:
+ amp_val_local = cand_a
+ except Exception:
+ pass
+ amplitude_slider = widgets.FloatSlider(value=amp_val_local, min=0.0, max=max(amp_default_local*5.0, amp_val_local, 1.0), step=max(amp_default_local*0.01, 0.01), description="A", continuous_update=False, style={"description_width": "auto"}, readout_format=".3f", layout=widgets.Layout(width="220px"))
+ alpha_val_local = DEFAULT_ALPHA
+ try:
+ if saved_alphas is not None and peak_idx < len(saved_alphas):
+ cand_alpha = float(saved_alphas[peak_idx])
+ if 0.0 <= cand_alpha <= 1.0:
+ alpha_val_local = cand_alpha
+ except Exception:
+ pass
+ alpha_slider = widgets.FloatSlider(value=alpha_val_local, min=0.0, max=1.0, step=0.01, description="α", continuous_update=False, readout_format=".2f", style={"description_width": "auto"}, layout=widgets.Layout(width="220px"))
+ include_val_local = True
+ try:
+ if saved_includes is not None and peak_idx < len(saved_includes):
+ include_val_local = bool(saved_includes[peak_idx])
+ except Exception:
+ pass
+ include_checkbox = widgets.Checkbox(value=include_val_local, description="Include peak in Fit", indent=False, layout=widgets.Layout(width="200px"))
+ try:
+ setattr(include_checkbox, '_original_idx', peak_idx)
+ except Exception:
+ pass
+ amp_mode_val_local = 'Auto'; center_mode_val_local = CENTER_MODE_WINDOW; sigma_mode_val_local = 'Auto'
+ try:
+ if saved_modes and isinstance(saved_modes.get('amplitude'), list) and peak_idx < len(saved_modes.get('amplitude')):
+ amp_mode_val_local = saved_modes['amplitude'][peak_idx]
+ if saved_modes and isinstance(saved_modes.get('center'), list) and peak_idx < len(saved_modes.get('center')):
+ center_mode_val_local = _normalize_center_mode_value(saved_modes['center'][peak_idx])
+ if saved_modes and isinstance(saved_modes.get('sigma'), list) and peak_idx < len(saved_modes.get('sigma')):
+ sigma_mode_val_local = saved_modes['sigma'][peak_idx]
+ except Exception:
+ pass
+ amp_mode_toggle = widgets.Dropdown(options=[('Auto','Auto'),('Manual','Manual')], value=amp_mode_val_local, layout=widgets.Layout(width='110px'), style={'description_width':'initial'}, description='')
+ center_mode_val_local = _normalize_center_mode_value(center_mode_val_local)
+ center_mode_toggle = widgets.Dropdown(options=CENTER_MODE_OPTIONS, value=center_mode_val_local, layout=widgets.Layout(width='110px'), style={'description_width':'initial'}, description='')
+ sigma_mode_toggle = widgets.Dropdown(options=[('Auto','Auto'),('Manual','Manual')], value=sigma_mode_val_local, layout=widgets.Layout(width='110px'), style={'description_width':'initial'}, description='')
+ try:
+ include_checkbox.observe(_on_include_toggle, names='value')
+ alpha_slider.observe(_on_alpha_change, names='value')
+ _bind_center_slider(center_slider, peak_idx, row_idx)
+ amplitude_slider.observe(_on_center_sigma_change, names='value')
+ center_window_slider.observe(_on_center_sigma_change, names='value')
+ def _on_sigma_change_stub(change, idx_local=peak_idx):
+ if sigma_mode_toggle.value == 'Manual':
+ # No persistence; maintain callback structure
+ _snapshot_current_controls()
+ sigma_slider.observe(_on_sigma_change_stub, names='value')
+ except Exception:
+ pass
+ details_box_local = cache_entry['details']
+ try:
+ amplitude_slider.description = ''
+ center_slider.description = ''
+ center_window_slider.description = '' # side label used instead
+ sigma_slider.description = ''
+ alpha_slider.description = ''
+ amplitude_slider.layout.width = '160px'
+ center_slider.layout.width = '160px'
+ center_window_slider.layout.width = '160px'
+ sigma_slider.layout.width = '160px'
+ alpha_slider.layout.width = '160px'
+ amplitude_slider._original_value = amplitude_slider.value # type: ignore[attr-defined]
+ center_slider._original_value = center_slider.value # type: ignore[attr-defined]
+ center_window_slider._original_value = center_window_slider.value # type: ignore[attr-defined]
+ sigma_slider._original_value = sigma_slider.value # type: ignore[attr-defined]
+ alpha_slider._original_value = alpha_slider.value # type: ignore[attr-defined]
+ def _mk_reset_local(target, default_cb=None):
+ btn = widgets.Button(description='Reset', layout=widgets.Layout(width='58px'))
+ def _on_click(_):
+ try:
+ if callable(default_cb):
+ candidate = default_cb()
+ if candidate is not None:
+ target.value = candidate
+ return
+ orig = getattr(target, '_original_value', None)
+ if orig is not None:
+ target.value = orig
+ except Exception:
+ pass
+ btn.on_click(_on_click)
+ return btn
+ amplitude_reset_l = _mk_reset_local(amplitude_slider)
+ def _center_reset_value_local():
+ try:
+ mode_val = center_mode_toggle.value
+ except Exception:
+ mode_val = CENTER_MODE_WINDOW
+ try:
+ base_val = float(initial_center_val)
+ except Exception:
+ base_val = initial_center_val
+ if mode_val == CENTER_MODE_EXACT:
+ return base_val
+ orig_local = getattr(center_slider, '_original_value', None)
+ return orig_local if orig_local is not None else base_val
+ center_reset_l = _mk_reset_local(center_slider, default_cb=_center_reset_value_local)
+ center_window_reset_l = _mk_reset_local(center_window_slider)
+ sigma_reset_l = _mk_reset_local(sigma_slider)
+ alpha_reset_l = _mk_reset_local(alpha_slider)
+ _row_layout_local = widgets.Layout(
+ display='flex', flex_flow='row nowrap', align_items='center',
+ gap='10px', overflow='visible', min_height='42px'
+ )
+ include_row_local = widgets.HBox([include_checkbox], layout=_row_layout_local)
+ mu_label_l = widgets.HTML('μ')
+ window_label_l = widgets.HTML('Window ± (cm⁻¹)')
+ mu_row_local = widgets.HBox([mu_label_l, center_mode_toggle, center_slider, center_reset_l, window_label_l, center_window_slider, center_window_reset_l], layout=_row_layout_local)
+ amplitude_label_l = widgets.HTML('A')
+ amplitude_row_local = widgets.HBox([amplitude_label_l, amp_mode_toggle, amplitude_slider, amplitude_reset_l], layout=_row_layout_local)
+ sigma_label_l = widgets.HTML('σ')
+ sigma_row_local = widgets.HBox([sigma_label_l, sigma_mode_toggle, sigma_slider, sigma_reset_l], layout=_row_layout_local)
+ alpha_row_local = widgets.HBox([widgets.HTML('α'), alpha_slider, alpha_reset_l], layout=_row_layout_local)
+ try:
+ details_box_local.layout.overflow = 'visible'
+ except Exception:
+ pass
+ def _sync_mode_visibility_local(*_):
+ # Amplitude row labels always visible
+ try:
+ if amp_mode_toggle.value == 'Auto':
+ amplitude_slider.layout.display = 'none'
+ amplitude_reset_l.layout.display = 'none'
+ else:
+ amplitude_slider.layout.display = 'block'
+ amplitude_reset_l.layout.display = 'block'
+ amplitude_label_l.layout.display = 'block'
+ except Exception:
+ pass
+ # Center / window handling
+ try:
+ center_slider.layout.display = 'block'
+ center_reset_l.layout.display = 'block'
+ if center_mode_toggle.value == CENTER_MODE_WINDOW:
+ center_window_slider.layout.display = 'block'
+ center_window_reset_l.layout.display = 'block'
+ window_label_l.layout.display = 'block'
+ else:
+ center_window_slider.layout.display = 'none'
+ center_window_reset_l.layout.display = 'none'
+ window_label_l.layout.display = 'none'
+ mu_label_l.layout.display = 'block'
+ except Exception:
+ pass
+ # Sigma row handling
+ try:
+ if sigma_mode_toggle.value == 'Auto':
+ sigma_slider.layout.display = 'none'
+ sigma_reset_l.layout.display = 'none'
+ else:
+ sigma_slider.layout.display = 'block'
+ sigma_reset_l.layout.display = 'block'
+ sigma_label_l.layout.display = 'block'
+ except Exception:
+ pass
+ try:
+ amp_mode_toggle.observe(_sync_mode_visibility_local, names='value')
+ center_mode_toggle.observe(_sync_mode_visibility_local, names='value')
+ sigma_mode_toggle.observe(_sync_mode_visibility_local, names='value')
+ except Exception:
+ pass
+ _sync_mode_visibility_local()
+ details_box_local.children = [include_row_local, alpha_row_local, mu_row_local, amplitude_row_local, sigma_row_local]
+ except Exception:
+ details_box_local.children = [alpha_slider, center_slider, center_window_slider, amplitude_slider, sigma_slider]
+ # Update cache with real widgets; store both 'amp_mode' and 'amplitude_mode' for consistency with downstream re-sync logic
+ cache_entry.update({
+ 'include': include_checkbox,
+ 'alpha': alpha_slider,
+ 'center': center_slider,
+ 'sigma': sigma_slider,
+ 'amplitude': amplitude_slider,
+ 'center_window': center_window_slider,
+ 'amp_mode': amp_mode_toggle,
+ 'amplitude_mode': amp_mode_toggle,
+ 'center_mode': center_mode_toggle,
+ 'sigma_mode': sigma_mode_toggle,
+ 'materialized': True
+ })
+ try:
+ # Replace placeholder references in master lists at index i so subsequent fits read real widgets directly
+ center_sliders[i] = center_slider
+ sigma_sliders[i] = sigma_slider
+ amplitude_sliders[i] = amplitude_slider
+ alpha_sliders[i] = alpha_slider
+ center_window_sliders[i] = center_window_slider
+ amplitude_mode_toggles[i] = amp_mode_toggle
+ center_mode_toggles[i] = center_mode_toggle
+ sigma_mode_toggles[i] = sigma_mode_toggle
+ _debug_log(f"[PEAK_MATERIALIZED] peak={peak_idx+1} center={center_slider.value} sigma={sigma_slider.value} amp={amplitude_slider.value} win={center_window_slider.value} modes c={center_mode_toggle.value} s={sigma_mode_toggle.value} a={amp_mode_toggle.value}")
+ except Exception:
+ pass
+ except Exception as e:
+ try:
+ import traceback
+ _DECONV_DEBUG_ERRORS.append(traceback.format_exc(limit=12))
+ except Exception:
+ pass
+ _lazy_debug(f"Fallback materialization failed for peak {peak_idx}: {e}")
+ try:
+ status_html.value = "Fallback materialization failed; disabling lazy mode."
+ except Exception:
+ pass
+ LAZY_PEAK_WIDGETS = False
+ return
+ # Toggle + empty details; materialization deferred until expand
+ details = widgets.VBox([]); details.layout.display = 'none'
+ toggle = widgets.ToggleButton(
+ value=False,
+ description=f"Peak {i+1}",
+ icon='chevron-down', layout=widgets.Layout(width='auto'),
+ tooltip='Show/hide peak parameter controls'
+ )
+ def _on_toggle_init(change, _t=toggle, _d=details, _idx=i):
+ # Declare global early since we conditionally reassign LAZY_PEAK_WIDGETS
+ global LAZY_PEAK_WIDGETS
+ if change.get('name') == 'value':
+ show = bool(change.get('new'))
+ _d.layout.display = 'block' if show else 'none'
+ try:
+ _t.icon = 'chevron-up' if show else 'chevron-down'
+ except Exception:
+ pass
+ if show:
+ # Instrument toggle open prior to any materialization attempt
+ try:
+ pre_mat = peak_box_cache.get(_idx, {}).get('materialized', False)
+ cur_center = None
+ try:
+ cent_obj = peak_box_cache.get(_idx, {}).get('center')
+ if cent_obj is not None:
+ cur_center = getattr(cent_obj, 'value', cent_obj)
+ except Exception:
+ cur_center = None
+ _debug_log(f"[PEAK_TOGGLE_OPEN] peak={_idx+1} pre_materialized={pre_mat} center={cur_center}")
+ except Exception:
+ pass
+ try:
+ if LAZY_PEAK_WIDGETS:
+ _materialize_peak(_idx)
+ else:
+ _materialize_peak(_idx, force=True)
+ # Post-materialization instrumentation
+ try:
+ entry = peak_box_cache.get(_idx, {})
+ post_mat = entry.get('materialized', False)
+ # Detect any remaining placeholder keys
+ placeholder_keys = []
+ try:
+ from inspect import isclass
+ except Exception:
+ pass
+ for k in ('center','sigma','amplitude','center_window','alpha','amp_mode','center_mode','sigma_mode'):
+ v = entry.get(k)
+ try:
+ if isinstance(v, (_LazyPlaceholder, _LazyModePlaceholder)):
+ placeholder_keys.append(k)
+ except Exception:
+ pass
+ post_center = None
+ try:
+ c_obj = entry.get('center')
+ if c_obj is not None:
+ post_center = getattr(c_obj, 'value', c_obj)
+ except Exception:
+ post_center = None
+ _debug_log(f"[PEAK_TOGGLE_AFTER] peak={_idx+1} materialized={post_mat} center={post_center} remaining_placeholders={placeholder_keys}")
+ except Exception:
+ pass
+ except Exception:
+ # Capture traceback for diagnostics
+ try:
+ import traceback
+ global _DECONV_DEBUG_ERRORS
+ _DECONV_DEBUG_ERRORS.append(traceback.format_exc(limit=12))
+ except Exception:
+ pass
+ _lazy_debug(f"Toggle init failed for peak {_idx}")
+ # Switch to eager mode and attempt forced build so user sees controls
+ try:
+ status_html.value = "Lazy materialization failed; forcing eager build."
+ except Exception:
+ pass
+ try:
+ LAZY_PEAK_WIDGETS = False
+ except Exception:
+ pass
+ try:
+ _materialize_peak(_idx, force=True)
+ except Exception:
+ pass
+ toggle.observe(_on_toggle_init, names='value')
+ box = widgets.VBox([toggle, details], layout=widgets.Layout(
+ border="2.5px solid #222", margin="12px 0", padding="16px 22px", border_radius="12px", background="#2d3748"
+ ))
+ try:
+ setattr(box, '_peak_idx', i)
+ except Exception:
+ pass
+ included_boxes.append(box)
+ # Cache placeholder entry only if not already materialized
+ if not (i in peak_box_cache and peak_box_cache[i].get('materialized')):
+ peak_box_cache[i] = {
+ 'box': box,
+ 'toggle': toggle,
+ 'details': details,
+ 'include': _LazyPlaceholder(True),
+ 'alpha': _LazyPlaceholder(DEFAULT_ALPHA),
+ 'center': _LazyPlaceholder(float(cx)),
+ 'sigma': _LazyPlaceholder(float(PER_PEAK_DEFAULT_SIGMA)),
+ 'amplitude': _LazyPlaceholder(abs(float(peaks_y_all[i])) * max(1.0, float(PER_PEAK_DEFAULT_SIGMA))),
+ 'center_window': _LazyPlaceholder(float(PER_PEAK_DEFAULT_CENTER_WINDOW)),
+ 'amp_mode': _LazyModePlaceholder('Auto'),
+ 'center_mode': _LazyModePlaceholder(CENTER_MODE_WINDOW),
+ 'sigma_mode': _LazyModePlaceholder('Auto'),
+ 'materialized': False,
+ }
+ _update_peak_toggle_label(i, spectrum_idx=row_idx)
+ # Populate accordion
+ try:
+ peak_accordion.children = tuple(included_boxes)
+ except Exception:
+ pass
+ # Update excluded peaks HTML
+ if excluded_peaks_list:
+ excluded_lines = [f"Peak {num} @ {val:.1f} cm⁻¹" for num, val in excluded_peaks_list]
+ excluded_peaks_html.value = (
+ "Excluded Peaks:" + "
".join(excluded_lines) + "
"
+ )
+ else:
+ excluded_peaks_html.value = "Excluded Peaks: None"
+ summary_html = widgets.HTML(
+ f"In-range peaks: {len(included_boxes)} / Total: {len(peaks_x_all)}"
+ )
+ param_row = _make_param_details_row()
+ peak_controls_box.children = [
+ widgets.HBox([param_row, summary_html]),
+ widgets.HTML("Included Peaks:"),
+ peak_accordion,
+ excluded_peaks_html,
+ ]
+ # Rebuild tracking lists using placeholders
+ alpha_sliders = []
+ include_checkboxes = []
+ center_sliders = []
+ center_slider_peak_indices = []
+ sigma_sliders = []
+ amplitude_sliders = []
+ center_window_sliders = []
+ amplitude_mode_toggles = []
+ center_mode_toggles = []
+ sigma_mode_toggles = []
+ for i in range(len(peaks_x_all)):
+ if i in peak_box_cache and i in new_in_range_set:
+ w = peak_box_cache[i]
+ include_checkboxes.append(w['include'])
+ alpha_sliders.append(w['alpha'])
+ center_sliders.append(w['center'])
+ center_slider_peak_indices.append(i)
+ sigma_sliders.append(w['sigma'])
+ amplitude_sliders.append(w['amplitude'])
+ center_window_sliders.append(w['center_window'])
+ amplitude_mode_toggles.append(w['amp_mode'])
+ center_mode_toggles.append(w['center_mode'])
+ sigma_mode_toggles.append(w['sigma_mode'])
+ try:
+ included_index_map[i] = w['toggle']
+ except Exception:
+ pass
+ # Attach canonical index to include checkbox for later mapping
+ try:
+ setattr(include_checkboxes[-1], '_original_idx', i)
+ except Exception:
+ pass
+ previous_in_range_indices = new_in_range_set
+ return
+
+ # --- Filtering helpers for material/conditions -> spectrum options ---
+ def _row_condition_value(row):
+ """Return the Conditions/Condition cell value for a DataFrame row."""
+ try:
+ return row.get("Conditions", row.get("Condition", ""))
+ except Exception:
+ return ""
+
+ def _filter_spectra_by_material_condition(df):
+ try:
+ include_bad_flag = bool(getattr(include_bad_cb, "value", True))
+ except Exception:
+ include_bad_flag = True
+ return _filter_spectra_dataframe(
+ df,
+ material=getattr(material_dd, "value", "any"),
+ condition=getattr(conditions_dd, "value", "any"),
+ include_bad=include_bad_flag,
+ include_unexposed=True,
+ normalized_column="Normalized and Corrected Data",
+ )
+
+ def _rebuild_spectrum_options(*_):
+ """Recompute the spectrum dropdown options based on current filters."""
+ nonlocal bulk_update_in_progress
+ # Build candidate set from initial 'filtered' and drop rows without normalized
+ # data
+ try:
+ cand = _filter_spectra_by_material_condition(filtered)
+ except Exception:
+ cand = filtered.copy()
+ try:
+ if "Time" in cand.columns:
+ cand = cand.copy()
+ cand["_sort_time"] = pd.to_numeric(cand["Time"], errors="coerce").fillna(float("inf"))
+ cand = cand.sort_values(by=["_sort_time"], kind="mergesort")
+ try:
+ cand = cand.drop(columns=["_sort_time"], errors="ignore")
+ except Exception:
+ pass
+ except Exception:
+ pass
+ # Read current filter selections
+ sel_mat = material_dd.value if hasattr(material_dd, "value") else "any"
+ sel_cond = conditions_dd.value if hasattr(conditions_dd, "value") else "any"
+
+ # Build new_options: list of (label, idx) for spectra matching current filters
+ new_options = []
+ for idx, r in cand.iterrows():
+ label = (
+ f"{r.get('Material','')} | {r.get('Conditions', r.get('Condition',''))}"
+ f" | T={r.get('Time','')} | {r.get('File Name','')}"
+ )
+ new_options.append((label, idx))
+
+ # Save current value before updating options
+ prev_value = spectrum_sel.value
+
+ valid_values = [v for (_lbl, v) in new_options]
+ value_changed = False
+ # Try to select a row matching the saved session 'time' (within current filters)
+ preferred_idx = None
+ try:
+ _sess = _get_session_defaults()
+ _sess_time = _sess.get("time", "any")
+ if _sess_time is not None and str(_sess_time).strip().lower() != "any":
+ # Compare numerically when possible, else fallback to string compare
+ for _lbl, _v in new_options:
+ try:
+ _tval = FTIR_DataFrame.loc[_v].get("Time")
+ # Numeric equality if both castable
+ try:
+ if float(_tval) == float(_sess_time):
+ preferred_idx = _v
+ break
+ except Exception:
+ if str(_tval) == str(_sess_time):
+ preferred_idx = _v
+ break
+ except Exception:
+ continue
+ except Exception:
+ preferred_idx = None
+ if preferred_idx in valid_values:
+ spectrum_sel.value = preferred_idx
+ value_changed = True
+ elif prev_value in valid_values:
+ # Only assign if the value actually needs to change
+ if spectrum_sel.value != prev_value:
+ spectrum_sel.value = prev_value
+ value_changed = True
+ elif valid_values:
+ spectrum_sel.value = valid_values[0]
+ value_changed = True
+ else:
+ # No spectra available, clear plot and controls
+ with fig.batch_update():
+ fig.data[0].x = []
+ fig.data[0].y = []
+ fig.data[1].x = []
+ fig.data[1].y = []
+ peak_controls_box.children = [
+ widgets.HTML("No spectra available after filtering.")
+ ]
+ _log_once("No spectra available after filtering selections.")
+ return
+ # Re-attach observer and trigger a single downstream update
+ try:
+ spectrum_sel.observe(_on_spectrum_change, names="value")
+ except Exception:
+ pass
+ # If we did not change the value (e.g., filters adjusted but selection stable),
+ # explicitly trigger one update to refresh controls/plot exactly once.
+ if not value_changed:
+ _on_spectrum_change()
+ try:
+ _update_spectrum_counter()
+ except Exception:
+ pass
+ # If no valid values remain, hide mark row until user selects something later
+ try:
+ if not valid_values and ('mark_row' in locals() or 'mark_row' in globals()):
+ mark_row.layout.display = "none"
+ except Exception:
+ pass
+
+ def _fit_and_update_plot(*_, ignore_debounce=False, override_ranges=None, update_plot=True, update_controls=True):
+ """Run a Pseudo-Voigt fit for the selected spectrum.
+
+ When update_plot is False, the fit still runs and redchi/result are
+ recorded, but Plotly traces are not updated.
+
+ When update_controls is False, status text and show/hide control
+ animations are suppressed.
+ """
+ nonlocal fit_thread, cancel_event, fit_cancel_token, iterating_in_progress
+ nonlocal fit_update_inflight, last_fit_update_ts
+ nonlocal alpha_sliders, include_checkboxes, center_sliders, sigma_sliders
+ nonlocal amplitude_sliders, center_window_sliders
+ nonlocal center_mode_toggles, sigma_mode_toggles, amplitude_mode_toggles
+ nonlocal status_html, fig, center_slider_peak_indices
+ nonlocal last_redchi_by_idx, last_result_by_idx
+
+ # Local helper to ensure logging occurs even if DECONV_DEBUG False (to diagnose why nothing changes)
+ def _log_dbg(tag: str, msg: str):
+ try:
+ _debug_log(f"[{tag}] {msg}")
+ except Exception:
+ pass
+
+ _log_dbg('FIT_START', 'Invoked _fit_and_update_plot')
+
+ # Guard reset helper (missing previously, causing NameError and hang)
+ def _finish_fit_guard():
+ nonlocal fit_update_inflight, last_fit_update_ts
+ fit_update_inflight = False
+ try:
+ last_fit_update_ts = time.time()
+ except Exception:
+ last_fit_update_ts = 0.0
+
+ def _sanitize_fit_ranges(ranges_in):
+ """Return list of (lo, hi) floats with NaNs removed and ordered."""
+ cleaned = []
+ if not ranges_in:
+ return cleaned
+ for pair in ranges_in:
+ try:
+ lo_val, hi_val = pair
+ except Exception:
+ continue
+ try:
+ lo_f = float(lo_val)
+ hi_f = float(hi_val)
+ except Exception:
+ continue
+ finite_ok = True
+ try:
+ finite_ok = bool(np.isfinite(lo_f)) and bool(np.isfinite(hi_f))
+ except Exception:
+ pass
+ if not finite_ok:
+ continue
+ if hi_f < lo_f:
+ lo_f, hi_f = hi_f, lo_f
+ cleaned.append((lo_f, hi_f))
+ return cleaned
+
+ # Debounce
+ try:
+ now_ts = time.time()
+ except Exception:
+ now_ts = 0.0
+ if fit_update_inflight:
+ _log_dbg('GUARD_SKIP', f"fit_update_inflight True; last_ts={last_fit_update_ts:.4f}")
+ return
+ delta_since_last = now_ts - last_fit_update_ts
+ if not ignore_debounce and (delta_since_last) < 0.03:
+ _log_dbg('DEBOUNCE_SKIP', f"delta={delta_since_last:.4f} < 0.03")
+ return
+ if ignore_debounce:
+ _log_dbg('DEBOUNCE_BYPASS', f"ignore_debounce=True; delta={delta_since_last:.4f}")
+ fit_update_inflight = True
+ _log_dbg('GUARD_SET', f"fit_update_inflight set True at ts={now_ts:.4f}")
+ if update_controls:
+ # Notify user immediately before any heavy per-peak inspection runs
+ if not iterating_in_progress:
+ try:
+ status_html.value = (
+ "Fitting..."
+ )
+ except Exception:
+ _log_once("Fitting...")
+ # Hide the same controls during Fit and optimization
+ try:
+ _hide_controls_during_fit_or_opt()
+ except Exception:
+ pass
+
+ # Snapshot current control state
+ try:
+ _snapshot_current_controls()
+ except Exception:
+ pass
+ if update_controls:
+ try:
+ _set_cancel_button_mode("optimize" if iterating_in_progress else "fit")
+ except Exception:
+ pass
+ try:
+ _force_cancel_fit_shown()
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_force_cancel_fit_shown)
+ except Exception:
+ pass
+
+ # Resolve current spectrum
+ try:
+ idx = spectrum_sel.value
+ except Exception:
+ idx = None
+ _log_dbg('SPECTRUM_IDX', f"idx={idx}")
+ if idx is None:
+ try:
+ status_html.value = "Select a spectrum before fitting."
+ except Exception:
+ _log_once("Select a spectrum before fitting.")
+ _log_dbg('ERROR', 'No spectrum selected; aborting fit')
+ _finish_fit_guard()
+ return
+ x_arr, y_arr = _get_xy(idx)
+ _log_dbg('DATA_SHAPE', f"x_arr={getattr(x_arr,'size',None)} y_arr={getattr(y_arr,'size',None)}")
+ if x_arr is None or y_arr is None or x_arr.size == 0:
+ try:
+ status_html.value = "No spectral data available for this row."
+ except Exception:
+ _log_once("No spectral data available for this row.")
+ _log_dbg('ERROR', 'Spectrum has no data; aborting fit')
+ _finish_fit_guard()
+ return
+ # Determine active fit ranges for this run (override or current slider selection)
+ if override_ranges is not None:
+ override_clean = _sanitize_fit_ranges(override_ranges)
+ else:
+ override_clean = None
+ if override_clean:
+ active_ranges = list(override_clean)
+ else:
+ try:
+ active_ranges = _sanitize_fit_ranges(_current_fit_ranges())
+ except Exception:
+ active_ranges = []
+ if not active_ranges:
+ try:
+ lo_full = float(np.nanmin(x_arr))
+ hi_full = float(np.nanmax(x_arr))
+ if hi_full < lo_full:
+ lo_full, hi_full = hi_full, lo_full
+ active_ranges = [(lo_full, hi_full)]
+ except Exception:
+ active_ranges = []
+ fit_ranges_for_this_run = list(active_ranges)
+ _log_dbg('ACTIVE_RANGES', f"fit_ranges_for_this_run={fit_ranges_for_this_run}")
+ peaks_x, peaks_y = _get_peaks(idx)
+ _log_dbg('PEAK_COUNTS', f"peaks_x_len={len(peaks_x)} peaks_y_len={len(peaks_y)}")
+ if not peaks_x:
+ try:
+ status_html.value = "No peaks found. Run peak-finding or add peaks."
+ except Exception:
+ _log_once("No peaks found. Run peak-finding or add peaks.")
+ # Clear component traces
+ try:
+ with fig.batch_update():
+ if len(fig.data) >= 2:
+ fig.data = tuple(fig.data[:2])
+ except Exception:
+ pass
+ _finish_fit_guard()
+ return
+ # Eager materialization fallback: if sliders/checkboxes not built yet (e.g., after Close),
+ # construct a minimal control set for all detected peaks using the full current span.
+ try:
+ if (not include_checkboxes) or (len(center_sliders) == 0):
+ # Clear any prior partial lists
+ include_checkboxes[:] = []
+ center_sliders[:] = []
+ sigma_sliders[:] = []
+ amplitude_sliders[:] = []
+ alpha_sliders[:] = []
+ center_window_sliders[:] = []
+ amplitude_mode_toggles[:] = []
+ center_mode_toggles[:] = []
+ sigma_mode_toggles[:] = []
+ center_slider_peak_indices[:] = []
+ # Derive default constants (fallbacks if not defined)
+ default_sigma = globals().get('PER_PEAK_DEFAULT_SIGMA', 5.0)
+ default_center_window = globals().get('PER_PEAK_DEFAULT_CENTER_WINDOW', 5.0)
+ # Build widgets
+ for pi, (px, py) in enumerate(zip(peaks_x, peaks_y)):
+ try:
+ pxv = float(px)
+ pyv = float(py)
+ except Exception:
+ continue
+ cb = widgets.Checkbox(value=True, description=f"Include {pi+1}")
+ include_checkboxes.append(cb)
+ center_slider = widgets.FloatSlider(value=pxv, min=pxv-abs(default_center_window), max=pxv+abs(default_center_window), step=max(abs(default_center_window)/200.0, 1e-3), description=f"Center {pi+1}", layout=widgets.Layout(width="48%"))
+ _set_peak_initial_center(idx, pi, pxv)
+ _set_peak_user_center(idx, pi, pxv)
+ center_sliders.append(center_slider)
+ sigma_slider = widgets.FloatSlider(value=default_sigma, min=1e-3, max=1e3, step=default_sigma/200.0 if default_sigma>0 else 0.1, description=f"Sigma {pi+1}", layout=widgets.Layout(width="48%"))
+ sigma_sliders.append(sigma_slider)
+ amp_guess = abs(pyv) * max(1.0, float(default_sigma))
+ amplitude_slider = widgets.FloatSlider(value=amp_guess, min=0.0, max=amp_guess * 10.0 if amp_guess>0 else 1.0, step=(amp_guess/200.0) if amp_guess>0 else 0.1, description=f"Amp {pi+1}", layout=widgets.Layout(width="48%"))
+ amplitude_sliders.append(amplitude_slider)
+ alpha_slider = widgets.FloatSlider(value=0.5, min=0.0, max=1.0, step=0.01, description=f"α {pi+1}", layout=widgets.Layout(width="48%"))
+ alpha_sliders.append(alpha_slider)
+ cwin_slider = widgets.FloatSlider(value=default_center_window, min=0.1, max=max(default_center_window*4.0, 1.0), step=max(default_center_window/200.0, 0.01), description=f"Win {pi+1}", layout=widgets.Layout(width="48%"))
+ center_window_sliders.append(cwin_slider)
+ amp_mode = widgets.Dropdown(options=['Auto','Manual'], value='Auto', description=f"A-mode {pi+1}")
+ center_mode = widgets.Dropdown(options=CENTER_MODE_OPTIONS, value=CENTER_MODE_WINDOW, description=f"C-mode {pi+1}")
+ sigma_mode = widgets.Dropdown(options=['Auto','Manual'], value='Auto', description=f"S-mode {pi+1}")
+ amplitude_mode_toggles.append(amp_mode)
+ center_mode_toggles.append(center_mode)
+ sigma_mode_toggles.append(sigma_mode)
+ center_slider_peak_indices.append(pi)
+ # Add to peak_controls_box if available
+ try:
+ peak_controls_box.children = tuple(list(peak_controls_box.children) + [widgets.HBox([cb, center_slider, sigma_slider, amplitude_slider, alpha_slider, cwin_slider, amp_mode, center_mode, sigma_mode])])
+ except Exception:
+ pass
+ try:
+ _bind_center_slider(center_slider, pi, idx)
+ except Exception:
+ pass
+ except Exception:
+ pass
+ # Rebuild included list using ORIGINAL peak indices (preserve visible numbering)
+ try:
+ for _chk_idx, _cb in enumerate(include_checkboxes):
+ # Attach original index if missing; center_slider_peak_indices holds original mapping
+ try:
+ if not hasattr(_cb, '_original_idx'):
+ _cb._original_idx = center_slider_peak_indices[_chk_idx] if _chk_idx < len(center_slider_peak_indices) else _chk_idx
+ except Exception:
+ pass
+ except Exception:
+ pass
+ included = []
+ try:
+ for _cb in include_checkboxes:
+ try:
+ if getattr(_cb, 'value', False):
+ included.append(getattr(_cb, '_original_idx', None))
+ except Exception:
+ pass
+ included = [i for i in included if i is not None]
+ except Exception:
+ pass
+ _log_dbg('INCLUDED', f"included_original_indices={included}")
+ blocked_labels = ""
+ blocked_included = []
+ try:
+ if 'peak_box_cache' in globals() and isinstance(peak_box_cache, dict):
+ filtered = []
+ for peak_idx in included:
+ entry = peak_box_cache.get(peak_idx)
+ if entry and entry.get('materialized'):
+ inc_widget = entry.get('include')
+ try:
+ inc_value = getattr(inc_widget, "value", True)
+ except Exception:
+ inc_value = True
+ try:
+ include_flag = bool(inc_value)
+ except Exception:
+ include_flag = True
+ if not include_flag:
+ blocked_included.append(peak_idx)
+ continue
+ filtered.append(peak_idx)
+ if blocked_included:
+ blocked_labels = ", ".join(f"Peak {pi+1}" for pi in blocked_included)
+ _log_dbg('INCLUDE_ENFORCE', f"Skipped materialized peaks without include checked: {[pi+1 for pi in blocked_included]}")
+ if filtered:
+ _log_once(f"Skipped {blocked_labels}; check 'Include peak in Fit' to include them.")
+ included = filtered
+ except Exception:
+ pass
+ # Enforce fit-range membership even when fallback controls create all peaks
+ slider_centers = {}
+ try:
+ for pos, orig_idx in enumerate(center_slider_peak_indices):
+ val = None
+ if pos < len(center_sliders):
+ slider_obj = center_sliders[pos]
+ try:
+ val = float(getattr(slider_obj, "value"))
+ except Exception:
+ val = None
+ needs_fallback = False
+ if val is None:
+ needs_fallback = True
+ else:
+ try:
+ if 'np' in globals() and hasattr(np, 'isfinite') and not np.isfinite(val):
+ needs_fallback = True
+ except Exception:
+ pass
+ if needs_fallback:
+ try:
+ val = float(peaks_x[orig_idx])
+ except Exception:
+ val = None
+ slider_centers[orig_idx] = val
+ except Exception:
+ pass
+ if fit_ranges_for_this_run:
+ filtered_included = []
+ dropped_for_range = []
+ for orig_idx in included:
+ center_val = slider_centers.get(orig_idx)
+ if center_val is None:
+ try:
+ center_val = float(peaks_x[orig_idx])
+ except Exception:
+ continue
+ try:
+ if 'np' in globals() and hasattr(np, 'isfinite') and not np.isfinite(center_val):
+ continue
+ except Exception:
+ pass
+ in_any = False
+ for lo_v, hi_v in fit_ranges_for_this_run:
+ try:
+ if lo_v <= center_val <= hi_v:
+ in_any = True
+ break
+ except Exception:
+ continue
+ if in_any:
+ filtered_included.append(orig_idx)
+ else:
+ dropped_for_range.append(orig_idx)
+ if dropped_for_range:
+ _log_dbg('RANGE_FILTER', f"Dropped peaks outside fit ranges: {[pi+1 for pi in dropped_for_range]}")
+ included = filtered_included
+ # Diagnostic: enumerate peaks whose center falls within current fit ranges
+ try:
+ fit_ranges_current = list(fit_ranges_for_this_run)
+ if not fit_ranges_current:
+ try:
+ fit_ranges_current = _sanitize_fit_ranges(_current_fit_ranges())
+ except Exception:
+ fit_ranges_current = []
+ in_range_lines = []
+ for orig_idx, cx in enumerate(peaks_x):
+ try:
+ cxf = float(cx)
+ except Exception:
+ continue
+ in_any = False
+ for rlo, rhi in fit_ranges_current:
+ try:
+ if rlo <= cxf <= rhi:
+ in_any = True; break
+ except Exception:
+ pass
+ if in_any:
+ try:
+ mat_flag = peak_box_cache.get(orig_idx, {}).get('materialized') if 'peak_box_cache' in globals() else None
+ except Exception:
+ mat_flag = None
+ in_range_lines.append(f"{orig_idx+1}:{cxf:.2f}:{'Y' if mat_flag else 'N'}")
+ if in_range_lines:
+ _debug_log(f"[IN_RANGE_PEAKS] {in_range_lines} (format originalIdx:center:materialized)")
+ except Exception:
+ pass
+ # Mapping no longer needed; included already carries original indices
+ if not included:
+ # Fallback: determine in-range peaks still marked for inclusion using persisted state.
+ available_in_range = []
+ try:
+ ranges_for_fallback = list(fit_ranges_for_this_run)
+ except Exception:
+ ranges_for_fallback = []
+ if not ranges_for_fallback:
+ try:
+ ranges_for_fallback = _sanitize_fit_ranges(_current_fit_ranges())
+ except Exception:
+ ranges_for_fallback = []
+
+ def _user_requested_include(orig_idx: int) -> bool:
+ # Consult the live include checkbox mapping if accessible.
+ try:
+ if center_slider_peak_indices and orig_idx in center_slider_peak_indices:
+ pos = center_slider_peak_indices.index(orig_idx)
+ if pos < len(include_checkboxes):
+ return bool(getattr(include_checkboxes[pos], 'value', True))
+ except Exception:
+ pass
+ try:
+ if orig_idx < len(include_checkboxes):
+ return bool(getattr(include_checkboxes[orig_idx], 'value', True))
+ except Exception:
+ pass
+ # Default to included when no explicit preference exists.
+ return True
+
+ if ranges_for_fallback:
+ for orig_idx, cx in enumerate(peaks_x):
+ try:
+ cx_val = float(cx)
+ except Exception:
+ continue
+ in_any = False
+ for lo_v, hi_v in ranges_for_fallback:
+ try:
+ if lo_v <= cx_val <= hi_v:
+ in_any = True
+ break
+ except Exception:
+ continue
+ if not in_any:
+ continue
+ if not _user_requested_include(orig_idx):
+ continue
+ available_in_range.append(orig_idx)
+
+ if available_in_range:
+ included = available_in_range
+ else:
+ try:
+ status_html.value = "No peaks selected."
+ except Exception:
+ _log_once("No peaks selected.")
+ _log_dbg('ERROR', 'No included peaks after fallback; aborting')
+ _finish_fit_guard()
+ return
+
+ # Re-sync slider references ONLY with fully materialized widgets.
+ # Previous logic overwrote real user-modified slider widgets with lazy placeholders,
+ # causing fits to ignore recent UI changes. We now preserve existing lists unless
+ # the cache entry is marked materialized (real ipywidgets object, not _LazyPlaceholder).
+ try:
+ if 'peak_box_cache' in globals() and isinstance(peak_box_cache, dict):
+ real_alpha = []
+ real_center = []
+ real_sigma = []
+ real_amp = []
+ real_center_window = []
+ # Also refresh mode toggles (previously omitted, causing stale 'Auto' captures)
+ real_amp_mode = []
+ real_center_mode = []
+ real_sigma_mode = []
+ for idx_slider, cb in enumerate(include_checkboxes):
+ # Map row position directly to canonical/original peak index
+ peak_idx = None
+ try:
+ if center_slider_peak_indices and idx_slider < len(center_slider_peak_indices):
+ peak_idx = center_slider_peak_indices[idx_slider]
+ except Exception:
+ peak_idx = None
+ if peak_idx is None:
+ # Secondary fallback: legacy included_index_map (if present)
+ try:
+ for k, v in included_index_map.items():
+ if v is cb:
+ peak_idx = k
+ break
+ except Exception:
+ peak_idx = None
+ if peak_idx is None:
+ peak_idx = idx_slider
+ entry = peak_box_cache.get(peak_idx)
+ if entry and entry.get('materialized'):
+ # Only adopt if a real widget (heuristic: has .observe attribute AND not our placeholder class)
+ def _use_or_fallback(key, fallback_list):
+ # Support legacy 'amp_mode' key alongside 'amplitude_mode'
+ w = entry.get(key)
+ if w is None and key == 'amplitude_mode':
+ w = entry.get('amp_mode')
+ try:
+ if w is None:
+ return fallback_list[idx_slider]
+ cls_name = w.__class__.__name__
+ if cls_name.startswith('_Lazy'):
+ # Placeholder; abort replacement for entire list
+ return fallback_list[idx_slider]
+ return w
+ except Exception:
+ return fallback_list[idx_slider]
+ real_alpha.append(_use_or_fallback('alpha', alpha_sliders))
+ real_center.append(_use_or_fallback('center', center_sliders))
+ real_sigma.append(_use_or_fallback('sigma', sigma_sliders))
+ real_amp.append(_use_or_fallback('amplitude', amplitude_sliders))
+ real_center_window.append(_use_or_fallback('center_window', center_window_sliders))
+ # Mode widgets: adopt if materialized; keys match those stored in cache entries
+ real_amp_mode.append(_use_or_fallback('amplitude_mode', amplitude_mode_toggles))
+ real_center_mode.append(_use_or_fallback('center_mode', center_mode_toggles))
+ real_sigma_mode.append(_use_or_fallback('sigma_mode', sigma_mode_toggles))
+ else:
+ # Keep the existing widget references
+ real_alpha.append(alpha_sliders[idx_slider])
+ real_center.append(center_sliders[idx_slider])
+ real_sigma.append(sigma_sliders[idx_slider])
+ real_amp.append(amplitude_sliders[idx_slider])
+ real_center_window.append(center_window_sliders[idx_slider])
+ try:
+ real_amp_mode.append(amplitude_mode_toggles[idx_slider])
+ real_center_mode.append(center_mode_toggles[idx_slider])
+ real_sigma_mode.append(sigma_mode_toggles[idx_slider])
+ except Exception:
+ pass
+ # Replace only if sizes match; otherwise keep originals
+ if (
+ len(real_alpha) == len(alpha_sliders)
+ and len(real_center) == len(center_sliders)
+ and len(real_amp_mode) == len(amplitude_mode_toggles)
+ and len(real_center_mode) == len(center_mode_toggles)
+ and len(real_sigma_mode) == len(sigma_mode_toggles)
+ ):
+ alpha_sliders = real_alpha
+ center_sliders = real_center
+ sigma_sliders = real_sigma
+ amplitude_sliders = real_amp
+ center_window_sliders = real_center_window
+ amplitude_mode_toggles = real_amp_mode
+ center_mode_toggles = real_center_mode
+ sigma_mode_toggles = real_sigma_mode
+ try:
+ _log_dbg('WIDGET_RESYNC', f"Resynced {len(center_sliders)} sliders & mode toggles from cache")
+ except Exception:
+ pass
+ # Final safeguard: force enumeration of actual displayed widgets in peak_controls_box
+ # Some user edits may occur on newly materialized widgets not yet reflected in cached lists.
+ try:
+ force_alpha = []
+ force_center = []
+ force_sigma = []
+ force_amp = []
+ force_center_window = []
+ force_amp_mode = []
+ force_center_mode = []
+ force_sigma_mode = []
+ force_include = []
+ # Each child HBox layout: [cb, center, sigma, amplitude, alpha, win, amp_mode, center_mode, sigma_mode]
+ for child in getattr(peak_controls_box, 'children', []):
+ try:
+ widgets_list = list(getattr(child, 'children', []))
+ if len(widgets_list) < 9:
+ continue
+ cb, c_sl, s_sl, a_sl, al_sl, w_sl, am_mode, c_mode, s_mode = widgets_list[:9]
+ force_include.append(cb)
+ force_center.append(c_sl)
+ force_sigma.append(s_sl)
+ force_amp.append(a_sl)
+ force_alpha.append(al_sl)
+ force_center_window.append(w_sl)
+ force_amp_mode.append(am_mode)
+ force_center_mode.append(c_mode)
+ force_sigma_mode.append(s_mode)
+ except Exception:
+ continue
+ if force_center and len(force_center) == len(center_sliders):
+ include_checkboxes = force_include
+ center_sliders = force_center
+ sigma_sliders = force_sigma
+ amplitude_sliders = force_amp
+ alpha_sliders = force_alpha
+ center_window_sliders = force_center_window
+ amplitude_mode_toggles = force_amp_mode
+ center_mode_toggles = force_center_mode
+ sigma_mode_toggles = force_sigma_mode
+ _log_dbg('WIDGET_FORCE_REFRESH', f"Forced refresh adopted {len(center_sliders)} live widget rows")
+ # Deep traversal fallback: some layouts may nest widgets more than one level.
+ try:
+ def _walk(node, acc):
+ try:
+ kids = getattr(node, 'children', [])
+ except Exception:
+ kids = []
+ for k in kids:
+ acc.append(k)
+ _walk(k, acc)
+ all_widgets = []
+ _walk(peak_controls_box, all_widgets)
+ # Maps for peak index 1 (0-based) by description pattern
+ desc_map = {
+ 'center': None,
+ 'sigma': None,
+ 'amp': None,
+ 'alpha': None,
+ 'win': None,
+ 'include': None,
+ 'A-mode': None,
+ 'C-mode': None,
+ 'S-mode': None,
+ }
+ for w in all_widgets:
+ try:
+ d = getattr(w, 'description', '')
+ except Exception:
+ continue
+ if not isinstance(d, str):
+ continue
+ if d.startswith('Center 1') and desc_map['center'] is None:
+ desc_map['center'] = w
+ elif d.startswith('Sigma 1') and desc_map['sigma'] is None:
+ desc_map['sigma'] = w
+ elif d.startswith('Amp 1') and desc_map['amp'] is None:
+ desc_map['amp'] = w
+ elif d.startswith('α 1') and desc_map['alpha'] is None:
+ desc_map['alpha'] = w
+ elif d.startswith('Win 1') and desc_map['win'] is None:
+ desc_map['win'] = w
+ elif d.startswith('Include 1') and desc_map['include'] is None:
+ desc_map['include'] = w
+ elif d.startswith('A-mode 1') and desc_map['A-mode'] is None:
+ desc_map['A-mode'] = w
+ elif d.startswith('C-mode 1') and desc_map['C-mode'] is None:
+ desc_map['C-mode'] = w
+ elif d.startswith('S-mode 1') and desc_map['S-mode'] is None:
+ desc_map['S-mode'] = w
+ # If we found a center or sigma widget whose value differs from our current list, adopt full deep set for index 0 only.
+ adopt = False
+ try:
+ if desc_map['center'] is not None and center_sliders and center_sliders[0] is not desc_map['center']:
+ adopt = True
+ if desc_map['sigma'] is not None and sigma_sliders and sigma_sliders[0] is not desc_map['sigma']:
+ adopt = True
+ # Value mismatch triggers adoption (user changed value on a different widget instance)
+ if desc_map['win'] is not None and center_window_sliders and abs(float(center_window_sliders[0].value) - float(getattr(desc_map['win'],'value', center_window_sliders[0].value))) > 1e-9:
+ adopt = True
+ except Exception:
+ pass
+ if adopt:
+ try:
+ center_sliders[0] = desc_map['center'] or center_sliders[0]
+ sigma_sliders[0] = desc_map['sigma'] or sigma_sliders[0]
+ amplitude_sliders[0] = desc_map['amp'] or amplitude_sliders[0]
+ alpha_sliders[0] = desc_map['alpha'] or alpha_sliders[0]
+ center_window_sliders[0] = desc_map['win'] or center_window_sliders[0]
+ amplitude_mode_toggles[0] = desc_map['A-mode'] or amplitude_mode_toggles[0]
+ center_mode_toggles[0] = desc_map['C-mode'] or center_mode_toggles[0]
+ sigma_mode_toggles[0] = desc_map['S-mode'] or sigma_mode_toggles[0]
+ _log_dbg('WIDGET_DEEP_REFRESH', 'Adopted deep traversal widgets for Peak 1')
+ except Exception:
+ pass
+ # Emit diagnostic snapshot of Peak 1 widget values right before parameter capture
+ try:
+ _log_dbg('PEAK1_WIDGET_VALUES', 'center={c} sigma={s} amp={a} win={w} modes center={mc} sigma={ms} amp={ma}'.format(
+ c=(center_sliders[0].value if center_sliders else 'NA'),
+ s=(sigma_sliders[0].value if sigma_sliders else 'NA'),
+ a=(amplitude_sliders[0].value if amplitude_sliders else 'NA'),
+ w=(center_window_sliders[0].value if center_window_sliders else 'NA'),
+ mc=(center_mode_toggles[0].value if center_mode_toggles else 'NA'),
+ ms=(sigma_mode_toggles[0].value if sigma_mode_toggles else 'NA'),
+ ma=(amplitude_mode_toggles[0].value if amplitude_mode_toggles else 'NA'),
+ ))
+ except Exception:
+ pass
+ except Exception:
+ pass
+ except Exception:
+ pass
+ except Exception:
+ pass
+ # Re-capture current widget parameter values and modes AFTER any re-sync so Manual changes are used.
+ param_seed_map = {}
+ # New: ensure all INCLUDED peaks are materialized so user edits apply.
+ try:
+ if 'peak_box_cache' in globals():
+ auto_mat = []
+ for _inc_idx in included:
+ try:
+ entry = peak_box_cache.get(_inc_idx)
+ if entry and not entry.get('materialized'):
+ # Programmatically open the toggle to invoke existing materialization logic
+ tg = None
+ toggled_open = False
+ try:
+ tg = entry.get('toggle')
+ if tg is not None:
+ try:
+ original_state = bool(tg.value)
+ except Exception:
+ original_state = True
+ if not original_state:
+ tg.value = True # triggers observer to materialize
+ toggled_open = True
+ except Exception:
+ pass
+ # Briefly poll to allow materialization observers to run
+ try:
+ import time as _time
+ except Exception:
+ _time = None
+ for _wait in range(10):
+ try:
+ entry = peak_box_cache.get(_inc_idx)
+ except Exception:
+ entry = None
+ if entry and entry.get('materialized'):
+ break
+ try:
+ if _time is not None:
+ _time.sleep(0.02)
+ except Exception:
+ pass
+ # Check final state
+ try:
+ entry = peak_box_cache.get(_inc_idx)
+ except Exception:
+ entry = None
+ if entry and entry.get('materialized'):
+ auto_mat.append(_inc_idx+1)
+ # Restore original toggle state so UIs stay collapsed after auto materialization
+ try:
+ if tg is not None and toggled_open:
+ tg.value = False
+ except Exception:
+ pass
+ # Ensure cache sync even if flag missing
+ try:
+ _ensure_cache_from_accordion(_inc_idx)
+ except Exception:
+ pass
+ try:
+ if peak_box_cache.get(_inc_idx, {}).get('materialized') and (_inc_idx+1) not in auto_mat:
+ auto_mat.append(_inc_idx+1)
+ except Exception:
+ pass
+ except Exception:
+ pass
+ if auto_mat:
+ _debug_log(f"[PEAK_AUTOMATERIALIZE] peaks={auto_mat} (forced materialization for included peaks)")
+ # Emit summary of included peaks materialization state
+ try:
+ mat_states = []
+ for _inc_idx in included:
+ try:
+ ms = peak_box_cache.get(_inc_idx, {}).get('materialized')
+ mat_states.append(f"{_inc_idx+1}:{'Y' if ms else 'N'}")
+ except Exception:
+ mat_states.append(f"{_inc_idx+1}:?")
+ _debug_log(f"[MATERIALIZATION_SUMMARY] included={ [i+1 for i in included] } states={mat_states}")
+ except Exception:
+ pass
+ except Exception:
+ pass
+ try:
+ # Optional mapping: if center_slider_peak_indices length matches center_sliders, use positional mapping.
+ for peak_idx in included:
+ # Determine positional index into slider lists via center_slider_peak_indices mapping
+ pos = peak_idx
+ if center_slider_peak_indices:
+ try:
+ pos = center_slider_peak_indices.index(peak_idx)
+ except Exception:
+ pos = peak_idx
+ original_idx_for_cache = peak_idx
+ # Extract values with fallbacks
+ def _val(lst, fallback):
+ try:
+ return float(lst[pos].value)
+ except Exception:
+ return float(fallback)
+ c_val = _val(center_sliders, peaks_x[peak_idx] if peak_idx < len(peaks_x) else float('nan'))
+ s_val = _val(sigma_sliders, globals().get('PER_PEAK_DEFAULT_SIGMA', 5.0))
+ a_val = _val(amplitude_sliders, (abs(float(peaks_y[peak_idx])) * max(1.0, s_val)) if peak_idx < len(peaks_y) else 1.0)
+ alpha_val = _val(alpha_sliders, 0.5)
+ w_val = _val(center_window_sliders, globals().get('PER_PEAK_DEFAULT_CENTER_WINDOW', 5.0))
+ def _mode(lst, key):
+ try:
+ m = lst[pos].value
+ except Exception:
+ m = 'Auto' if key in ('amplitude','sigma') else CENTER_MODE_WINDOW
+ if key == 'center':
+ return _normalize_center_mode_value(m)
+ if m not in ('Auto','Manual'):
+ m = 'Auto'
+ return m
+ # Cache-first capture: if peak has been materialized, read directly from cache widgets.
+ source = 'list'
+ placeholder_flags = []
+ cache_entry = None
+ try:
+ if 'peak_box_cache' in globals():
+ cache_entry = peak_box_cache.get(original_idx_for_cache)
+ except Exception:
+ cache_entry = None
+ if cache_entry and cache_entry.get('materialized'):
+ try:
+ c_val = float(getattr(cache_entry.get('center'), 'value', c_val))
+ s_val = float(getattr(cache_entry.get('sigma'), 'value', s_val))
+ a_val = float(getattr(cache_entry.get('amplitude'), 'value', a_val))
+ alpha_val = float(getattr(cache_entry.get('alpha'), 'value', alpha_val))
+ w_val = float(getattr(cache_entry.get('center_window'), 'value', w_val))
+ mode_center = _normalize_center_mode_value(getattr(cache_entry.get('center_mode'), 'value', CENTER_MODE_WINDOW))
+ mode_sigma = str(getattr(cache_entry.get('sigma_mode'), 'value', 'Auto'))
+ mode_amp = str(getattr(cache_entry.get('amplitude_mode') or cache_entry.get('amp_mode'), 'value', 'Auto'))
+ source = 'cache'
+ except Exception:
+ source = 'cache_partial'
+ mode_center = _mode(center_mode_toggles, 'center')
+ mode_sigma = _mode(sigma_mode_toggles, 'sigma')
+ mode_amp = _mode(amplitude_mode_toggles, 'amplitude')
+ else:
+ # Attempt to recover materialized widgets from accordion if flag missing
+ try:
+ _ensure_cache_from_accordion(original_idx_for_cache)
+ cache_entry = peak_box_cache.get(original_idx_for_cache)
+ if cache_entry and cache_entry.get('materialized'):
+ c_val = float(getattr(cache_entry.get('center'), 'value', c_val))
+ s_val = float(getattr(cache_entry.get('sigma'), 'value', s_val))
+ a_val = float(getattr(cache_entry.get('amplitude'), 'value', a_val))
+ alpha_val = float(getattr(cache_entry.get('alpha'), 'value', alpha_val))
+ w_val = float(getattr(cache_entry.get('center_window'), 'value', w_val))
+ mode_center = _normalize_center_mode_value(getattr(cache_entry.get('center_mode'), 'value', CENTER_MODE_WINDOW))
+ mode_sigma = str(getattr(cache_entry.get('sigma_mode'), 'value', 'Auto'))
+ mode_amp = str(getattr(cache_entry.get('amplitude_mode') or cache_entry.get('amp_mode'), 'value', 'Auto'))
+ source = 'cache'
+ else:
+ raise RuntimeError('Accordion recovery not materialized')
+ except Exception:
+ pass
+ # Try to read directly from live row widgets by original peak number
+ live_row_found = False
+ try:
+ for child in getattr(peak_controls_box, 'children', []):
+ try:
+ widgets_list = list(getattr(child, 'children', []))
+ if len(widgets_list) < 9:
+ continue
+ cb, c_sl, s_sl, a_sl, al_sl, w_sl, am_mode, c_mode, s_mode = widgets_list[:9]
+ desc = getattr(cb, 'description', '')
+ if isinstance(desc, str) and desc.strip() == f"Include {original_idx_for_cache+1}":
+ c_val = float(getattr(c_sl, 'value', c_val))
+ s_val = float(getattr(s_sl, 'value', s_val))
+ a_val = float(getattr(a_sl, 'value', a_val))
+ alpha_val = float(getattr(al_sl, 'value', alpha_val))
+ w_val = float(getattr(w_sl, 'value', w_val))
+ mode_center = _normalize_center_mode_value(getattr(c_mode, 'value', CENTER_MODE_WINDOW))
+ mode_sigma = str(getattr(s_mode, 'value', 'Auto'))
+ mode_amp = str(getattr(am_mode, 'value', 'Auto'))
+ source = 'cache' # treat live widgets as authoritative
+ live_row_found = True
+ break
+ except Exception:
+ continue
+ except Exception:
+ live_row_found = False
+ if not live_row_found:
+ # Fallback to list-based modes and note placeholders
+ mode_center = _mode(center_mode_toggles, 'center')
+ mode_sigma = _mode(sigma_mode_toggles, 'sigma')
+ mode_amp = _mode(amplitude_mode_toggles, 'amplitude')
+ def _is_placeholder(lst):
+ try:
+ cls_name = lst[pos].__class__.__name__
+ return cls_name.startswith('_Lazy')
+ except Exception:
+ return False
+ for name,lst in [('center',center_sliders),('sigma',sigma_sliders),('amp',amplitude_sliders)]:
+ if _is_placeholder(lst):
+ placeholder_flags.append(name)
+ param_seed_map[original_idx_for_cache] = {
+ 'center': c_val,
+ 'sigma': s_val,
+ 'amplitude': a_val,
+ 'alpha': alpha_val,
+ 'center_window': w_val,
+ 'mode_center': mode_center,
+ 'mode_sigma': mode_sigma,
+ 'mode_amp': mode_amp,
+ 'placeholders': placeholder_flags,
+ 'source': source,
+ 'original_idx': original_idx_for_cache,
+ }
+ try:
+ _debug_log(f"[PARAM_CAPTURE] peak={original_idx_for_cache+1} source={source} center={c_val} sigma={s_val} amp={a_val} win={w_val} modes c={mode_center} s={mode_sigma} a={mode_amp} placeholders={placeholder_flags}")
+ # Additional per-peak detail: widget classes and materialized flag
+ try:
+ if cache_entry:
+ cls_center = cache_entry.get('center').__class__.__name__ if cache_entry.get('center') is not None else 'None'
+ cls_sigma = cache_entry.get('sigma').__class__.__name__ if cache_entry.get('sigma') is not None else 'None'
+ cls_amp = cache_entry.get('amplitude').__class__.__name__ if cache_entry.get('amplitude') is not None else 'None'
+ _debug_log(f"[PARAM_CAPTURE_DETAIL] peak={original_idx_for_cache+1} materialized={cache_entry.get('materialized')} classes center={cls_center} sigma={cls_sigma} amp={cls_amp}")
+ except Exception:
+ pass
+ except Exception:
+ pass
+ # Emit diagnostic for first included peak (usually Peak 1)
+ first_original = included[0]
+ seed_first = param_seed_map.get(first_original, {})
+ _debug_log("[PARAM_SEED_CAPTURED] peak={} center={} sigma={} amp={} win={} modes c={} s={} a={} placeholders={}".format(
+ first_original+1,
+ seed_first.get('center','NA'),
+ seed_first.get('sigma','NA'),
+ seed_first.get('amplitude','NA'),
+ seed_first.get('center_window','NA'),
+ seed_first.get('mode_center','NA'),
+ seed_first.get('mode_sigma','NA'),
+ seed_first.get('mode_amp','NA'),
+ seed_first.get('placeholders','NA'),
+ ))
+ # Materialized peaks that are currently not part of this fit (user may have edited but range excludes them)
+ try:
+ if 'peak_box_cache' in globals():
+ materialized_not_included = [i+1 for i,entry in peak_box_cache.items() if entry.get('materialized') and i not in included]
+ if materialized_not_included:
+ _debug_log(f"[OPEN_NOT_INCLUDED] peaks={materialized_not_included} (materialized but excluded by current fit range)")
+ except Exception:
+ pass
+ except Exception:
+ pass
+
+ if update_plot:
+ # Prepare component traces count on main thread for consistent layout
+ comp_traces_needed = len(included)
+ with fig.batch_update():
+ current_components = max(0, len(fig.data) - 2)
+ if current_components > comp_traces_needed:
+ fig.data = tuple(list(fig.data)[: 2 + comp_traces_needed])
+ elif current_components < comp_traces_needed:
+ for _k in range(comp_traces_needed - current_components):
+ # Placeholder name will be updated after fit with actual peak number
+ fig.add_scatter(
+ x=[],
+ y=[],
+ mode="lines",
+ line=dict(dash="dot"),
+ name="Peak ?",
+ )
+
+ # Cancel any running fit and start a new one in the background
+ try:
+ if fit_thread is not None and fit_thread.is_alive():
+ # Signal the currently running worker to stop (per-fit only)
+ try:
+ if fit_cancel_token is not None:
+ fit_cancel_token.set()
+ except Exception:
+ pass
+ except Exception:
+ pass
+ # Create a fresh cancel token for this new worker and capture it locally
+ local_cancel = threading.Event()
+ # Keep the global cancel_event stable; only update the active per-fit token
+ fit_cancel_token = local_cancel
+
+ old_redchi = last_redchi_by_idx.get(idx, None)
+ _log_dbg('OLD_REDCHI', f"old_redchi={old_redchi}")
+ if update_controls:
+ # Update status label immediately on main thread
+ if not iterating_in_progress:
+ try:
+ status_html.value = (
+ "Refitting..."
+ if old_redchi is not None
+ else "Fitting..."
+ )
+ except Exception:
+ _log_once("Refitting..." if old_redchi is not None else "Fitting...")
+
+ def _worker(local_cancel_token=local_cancel, forced_ranges=fit_ranges_for_this_run):
+ nonlocal fit_thread
+ try:
+ _log_dbg('WORKER_START', 'Background worker thread started')
+ # Use only the selected Fit X-range (or override) for fitting to prevent
+ # components going nearly flat when focusing on a small region.
+ if forced_ranges:
+ ranges = _sanitize_fit_ranges(forced_ranges)
+ else:
+ try:
+ ranges = _sanitize_fit_ranges(_current_fit_ranges())
+ except Exception:
+ ranges = []
+
+ if not ranges:
+ try:
+ if 'np' in globals():
+ lo_full = float(np.nanmin(x_arr))
+ hi_full = float(np.nanmax(x_arr))
+ else:
+ lo_full = float(min(x_arr))
+ hi_full = float(max(x_arr))
+ if hi_full < lo_full:
+ lo_full, hi_full = hi_full, lo_full
+ ranges = [(lo_full, hi_full)]
+ except Exception:
+ ranges = []
+
+ _log_dbg('FIT_RANGES', f"ranges={ranges}")
+
+ try:
+ msk = np.zeros_like(x_arr, dtype=bool)
+ if ranges:
+ for lo_v, hi_v in ranges:
+ msk |= ((x_arr >= lo_v) & (x_arr <= hi_v))
+ else:
+ msk[:] = True
+ except Exception:
+ msk = np.ones_like(x_arr, dtype=bool)
+ x_sub = x_arr[msk]
+ y_sub = y_arr[msk]
+ _log_dbg('SUBSET_SHAPE', f"x_sub={x_sub.size} y_sub={y_sub.size}")
+ # If too few points in range, bail gracefully
+ if x_sub.size < max(10, 3 * max(1, len(included))):
+ _on_main_thread(
+ lambda: _log_once(
+ "Selected Fit X-range has too few points for a stable fit. "
+ "Expand the range or include more peaks."
+ )
+ )
+ _finish_fit_guard()
+ return
+
+ # Pre-fit sanity: ensure included indices are within bounds
+ try:
+ valid_included = []
+ dropped = []
+ px_len = int(len(peaks_x))
+ py_len = int(len(peaks_y))
+ for i in included:
+ try:
+ if isinstance(i, (int, float)):
+ ii = int(i)
+ else:
+ ii = int(i)
+ except Exception:
+ dropped.append(i)
+ continue
+ if ii < 0 or ii >= px_len or ii >= py_len:
+ dropped.append(ii)
+ else:
+ valid_included.append(ii)
+ if dropped:
+ _on_main_thread(lambda: _log_once(f"Dropped invalid peaks: {', '.join('Peak '+str(di+1) for di in dropped if isinstance(di,int))}"))
+ included[:] = valid_included
+ except Exception:
+ pass
+ if not included:
+ _on_main_thread(lambda: _log_once("No valid peaks remain after deletion; nothing to fit."))
+ _finish_fit_guard()
+ return
+
+ # Build composite model using captured param_seed_map snapshot
+ comp_model = None
+ params = None
+ param_pre_lines = []
+ for i in included:
+ try:
+ seed = param_seed_map.get(i, {})
+ mu_val = float(seed.get('center', peaks_x[i]))
+ sg_val = float(seed.get('sigma', globals().get('PER_PEAK_DEFAULT_SIGMA', 5.0)))
+ amp_val = float(seed.get('amplitude', abs(float(peaks_y[i])) * max(1.0, sg_val)))
+ alpha_val = float(seed.get('alpha', 0.5))
+ w = float(seed.get('center_window', globals().get('PER_PEAK_DEFAULT_CENTER_WINDOW', 5.0)))
+ mode_center = _normalize_center_mode_value(seed.get('mode_center', CENTER_MODE_WINDOW))
+ mode_sigma = seed.get('mode_sigma', 'Auto')
+ mode_amp = seed.get('mode_amp', 'Auto')
+ if mode_sigma not in ('Auto','Manual'):
+ mode_sigma = 'Auto'
+ if mode_amp not in ('Auto','Manual'):
+ mode_amp = 'Auto'
+ m = PseudoVoigtModel(prefix=f"p{i}_")
+ p = m.make_params()
+ # Center
+ if mode_center == CENTER_MODE_EXACT:
+ p[f"p{i}_center"].set(value=mu_val, vary=False)
+ else:
+ p[f"p{i}_center"].set(value=mu_val, min=mu_val - abs(w), max=mu_val + abs(w), vary=True)
+ # Sigma
+ if mode_sigma == 'Manual':
+ p[f"p{i}_sigma"].set(value=sg_val, vary=False)
+ else:
+ p[f"p{i}_sigma"].set(value=sg_val, min=1e-3, max=1e3, vary=True)
+ # Alpha fixed
+ p[f"p{i}_fraction"].set(value=alpha_val, min=0.0, max=1.0, vary=False)
+ # Amplitude
+ if mode_amp == 'Manual':
+ p[f"p{i}_amplitude"].set(value=amp_val, vary=False)
+ else:
+ p[f"p{i}_amplitude"].set(value=amp_val, min=0.0)
+ # Snapshot line
+ param_pre_lines.append(
+ f"Peak {i+1} PRE center={mu_val:.6g} mode={mode_center} sigma={sg_val:.6g} mode={mode_sigma} amp={amp_val:.6g} mode={mode_amp} alpha={alpha_val:.6g} fixed win={w:.6g}"
+ )
+ if comp_model is None:
+ comp_model = m
+ params = p
+ else:
+ comp_model = comp_model + m
+ params.update(p)
+ except Exception as e:
+ _log_once(f"Error setting up parameters for peak {i+1}: {e}")
+ _finish_fit_guard()
+ return
+
+ # Emit captured parameter snapshot (PRE) for debugging
+ if param_pre_lines:
+ try:
+ if DECONV_DEBUG:
+ _debug_log("[DECONV_DEBUG] PRE-fit parameter snapshot (" + str(len(param_pre_lines)) + " peaks):")
+ for line in param_pre_lines:
+ _debug_log(line)
+ else:
+ _debug_log(f"[PRE_CAPTURE] Captured {len(param_pre_lines)} peak parameter lines (debug flag off)")
+ except Exception:
+ pass
+ else:
+ _log_dbg('PRE_PARAMS_EMPTY', 'No param_pre_lines captured at all')
+
+ # iter_cb to allow cooperative cancellation
+ def _iter_cb(params_, iter_, resid_, *args, **kws):
+ if local_cancel_token.is_set():
+ raise KeyboardInterrupt("Fit cancelled by user")
+
+ _log_dbg('LMFIT_START', f"Starting lmfit with {len(included)} components")
+ result = comp_model.fit(y_sub, params, x=x_sub, iter_cb=_iter_cb)
+ _log_dbg('LMFIT_DONE', f"Fit result redchi={getattr(result,'redchi',None)}")
+ if local_cancel_token.is_set():
+ return
+ # Evaluate results for full x-array for plotting (optional)
+ if update_plot:
+ y_fit = result.eval(x=x_arr)
+ comps = result.eval_components(x=x_arr)
+ else:
+ y_fit = None
+ comps = None
+
+ # Post-fit parameter snapshot & mode/vary verification
+ # Post-fit snapshot (always capture; conditional detailed logging)
+ if True:
+ try:
+ param_post_lines = []
+ vary_mismatches = []
+ for i in included:
+ prefix = f"p{i}_"
+ def _pv(name):
+ try:
+ par = result.params.get(prefix + name)
+ return float(getattr(par, 'value', par))
+ except Exception:
+ return float('nan')
+ c_val = _pv('center')
+ s_val = _pv('sigma')
+ a_val = _pv('amplitude')
+ fr_val = _pv('fraction')
+ try:
+ raw_center_mode = center_mode_toggles[i].value if i < len(center_mode_toggles) else CENTER_MODE_WINDOW
+ except Exception:
+ raw_center_mode = CENTER_MODE_WINDOW
+ mode_center = _normalize_center_mode_value(raw_center_mode)
+ try:
+ mode_sigma = sigma_mode_toggles[i].value if i < len(sigma_mode_toggles) else 'Auto'
+ except Exception:
+ mode_sigma = 'Auto'
+ try:
+ mode_amp = amplitude_mode_toggles[i].value if i < len(amplitude_mode_toggles) else 'Auto'
+ except Exception:
+ mode_amp = 'Auto'
+ def _vary(name):
+ try:
+ par = result.params.get(prefix + name)
+ return bool(getattr(par, 'vary', False))
+ except Exception:
+ return False
+ vc = _vary('center')
+ vs = _vary('sigma')
+ va = _vary('amplitude')
+ if (mode_center == CENTER_MODE_EXACT and vc) or (mode_center == CENTER_MODE_WINDOW and not vc):
+ vary_mismatches.append(f"Peak {i+1} center mode={mode_center} vary={vc}")
+ if (mode_sigma == 'Manual' and vs) or (mode_sigma == 'Auto' and not vs):
+ vary_mismatches.append(f"Peak {i+1} sigma mode={mode_sigma} vary={vs}")
+ if (mode_amp == 'Manual' and va) or (mode_amp == 'Auto' and not va):
+ vary_mismatches.append(f"Peak {i+1} amplitude mode={mode_amp} vary={va}")
+ param_post_lines.append(
+ f"Peak {i+1} POST center={c_val:.6g} vary={vc} sigma={s_val:.6g} vary={vs} amp={a_val:.6g} vary={va} alpha={fr_val:.6g} fixed"
+ )
+ if DECONV_DEBUG:
+ _debug_log("[DECONV_DEBUG] POST-fit parameter snapshot (" + str(len(param_post_lines)) + " peaks):")
+ for line in param_post_lines:
+ _debug_log(line)
+ if vary_mismatches:
+ _debug_log("[DECONV_DEBUG] VARY FLAG MISMATCHES: " + "; ".join(vary_mismatches))
+ else:
+ _debug_log("[DECONV_DEBUG] VARY FLAGS OK")
+ else:
+ _debug_log(f"[POST_CAPTURE] Captured {len(param_post_lines)} peak parameter lines (debug flag off)")
+ if vary_mismatches:
+ _debug_log("[POST_CAPTURE] VARY FLAG MISMATCHES: " + "; ".join(vary_mismatches))
+ else:
+ _debug_log("[POST_CAPTURE] VARY FLAGS OK")
+ except Exception:
+ pass
+
+ # Persist last successful result for this spectrum
+ try:
+ last_result_by_idx[idx] = result
+ except Exception:
+ pass
+
+ # Persist redchi immediately (used by silent objective evaluation)
+ try:
+ rc_val = getattr(result, "redchi", None)
+ if rc_val is not None:
+ try:
+ last_redchi_by_idx[idx] = float(rc_val)
+ except Exception:
+ last_redchi_by_idx[idx] = rc_val
+ except Exception:
+ pass
+
+ # Silent mode: do not touch the UI/plot; just clear guards.
+ if (not update_plot) and (not update_controls):
+ try:
+ fit_thread = None
+ except Exception:
+ pass
+ try:
+ _finish_fit_guard()
+ except Exception:
+ pass
+ return
+
+ def _apply_results_on_ui():
+ nonlocal iter_summary_pending, iter_start_redchi, iter_final_redchi
+ # Always try to update the plot, but don't let plotting failures
+ # prevent status messages from updating.
+ plot_ok = True
+ try:
+ comp_traces_needed = len(included)
+ with fig.batch_update():
+ # Ensure we have exactly 2 + comp_traces_needed traces
+ current_components = max(0, len(fig.data) - 2)
+ if current_components > comp_traces_needed:
+ fig.data = tuple(
+ list(fig.data)[: 2 + comp_traces_needed]
+ )
+ elif current_components < comp_traces_needed:
+ for _k in range(
+ comp_traces_needed - current_components
+ ):
+ fig.add_scatter(
+ x=[],
+ y=[],
+ mode="lines",
+ line=dict(dash="dot"),
+ name="Peak ?",
+ )
+ # Update data and fit traces
+ fig.data[0].x = x_arr.tolist()
+ fig.data[0].y = y_arr.tolist()
+ fig.data[1].x = x_arr.tolist()
+ fig.data[1].y = (
+ y_fit.tolist()
+ if hasattr(y_fit, "tolist")
+ else list(y_fit)
+ )
+ # Update component traces safely
+ for comp_pos, orig_idx in enumerate(included):
+ key = f"p{orig_idx}_"
+ y_comp = comps.get(key, np.zeros_like(x_arr))
+ fig.data[2 + comp_pos].x = x_arr.tolist()
+ fig.data[2 + comp_pos].y = (
+ y_comp.tolist()
+ if hasattr(y_comp, "tolist")
+ else list(y_comp)
+ )
+ # Ensure component names reflect peak number and FINAL fitted center value
+ try:
+ mu_display = None
+ try:
+ par_obj = result.params.get(f"p{orig_idx}_center")
+ if par_obj is not None:
+ mu_display = float(getattr(par_obj, 'value', par_obj))
+ except Exception:
+ mu_display = None
+ if mu_display is None:
+ try:
+ # orig_idx corresponds to slider index; use direct lookup
+ mu_display = float(center_sliders[orig_idx].value) if orig_idx < len(center_sliders) else float(peaks_x[orig_idx])
+ except Exception:
+ mu_display = float(peaks_x[orig_idx]) if orig_idx < len(peaks_x) else float('nan')
+ # Legend numbering uses original peak index (i+1) to match toggle titles
+ fig.data[2 + comp_pos].name = f"Peak {orig_idx+1} @ {mu_display:.1f} cm⁻¹"
+ try:
+ _set_peak_fit_center(idx, orig_idx, mu_display)
+ except Exception:
+ pass
+ try:
+ _update_peak_toggle_label(orig_idx, spectrum_idx=idx)
+ except Exception:
+ pass
+ except Exception:
+ pass
+ # Keep slider widgets in sync with fitted parameter values so the UI
+ # reflects the latest optimization step even when it ran off-thread.
+ try:
+ for orig_idx in included:
+ pos = None
+ if center_slider_peak_indices:
+ try:
+ pos = center_slider_peak_indices.index(orig_idx)
+ except ValueError:
+ pos = None
+ if pos is None and orig_idx < len(center_sliders):
+ pos = orig_idx
+ cache_entry = None
+ try:
+ if isinstance(peak_box_cache, dict):
+ cache_entry = peak_box_cache.get(orig_idx)
+ except Exception:
+ cache_entry = None
+ def _real_widget(candidate, fallback_list):
+ if candidate is not None and hasattr(candidate, "value"):
+ return candidate
+ if pos is None:
+ return None
+ if fallback_list is None:
+ return None
+ try:
+ if pos < len(fallback_list):
+ widget_obj = fallback_list[pos]
+ if hasattr(widget_obj, "value"):
+ return widget_obj
+ except Exception:
+ pass
+ return None
+ sigma_widget = _real_widget(
+ cache_entry.get("sigma") if cache_entry else None,
+ sigma_sliders,
+ )
+ amplitude_widget = _real_widget(
+ cache_entry.get("amplitude") if cache_entry else None,
+ amplitude_sliders,
+ )
+ prefix = f"p{orig_idx}_"
+ try:
+ par_center = result.params.get(prefix + "center")
+ except Exception:
+ par_center = None
+ if par_center is not None:
+ try:
+ center_val = float(getattr(par_center, "value", par_center))
+ _set_peak_fit_center(idx, orig_idx, center_val)
+ except Exception:
+ _set_peak_fit_center(idx, orig_idx, par_center)
+ try:
+ _update_peak_toggle_label(orig_idx, spectrum_idx=idx)
+ except Exception:
+ pass
+ try:
+ par_sigma = result.params.get(prefix + "sigma")
+ except Exception:
+ par_sigma = None
+ if (
+ par_sigma is not None
+ and sigma_widget is not None
+ and hasattr(sigma_widget, "value")
+ ):
+ try:
+ sigma_val = float(getattr(par_sigma, "value", par_sigma))
+ _set_quiet(sigma_widget, "value", sigma_val)
+ except Exception:
+ pass
+ try:
+ par_amp = result.params.get(prefix + "amplitude")
+ except Exception:
+ par_amp = None
+ if (
+ par_amp is not None
+ and amplitude_widget is not None
+ and hasattr(amplitude_widget, "value")
+ ):
+ try:
+ amp_val = float(getattr(par_amp, "value", par_amp))
+ _set_quiet(amplitude_widget, "value", amp_val)
+ except Exception:
+ pass
+ except Exception:
+ pass
+ try:
+ _snapshot_current_controls()
+ except Exception:
+ pass
+ except Exception:
+ plot_ok = False
+ # Update message regardless of plot success
+ # Update status label text (suppressed during iterative correction)
+ new_redchi = getattr(result, "redchi", np.nan)
+ try:
+ if not iterating_in_progress:
+ # If an iteration just completed, prefer the pre- vs
+ # post-iteration summary
+ if (
+ iter_summary_pending
+ and iter_start_redchi is not None
+ and iter_final_redchi is not None
+ ):
+ try:
+ old_str = f"{float(iter_start_redchi):.4g}"
+ except Exception:
+ old_str = str(iter_start_redchi)
+ try:
+ new_str = f"{float(iter_final_redchi):.4g}"
+ except Exception:
+ new_str = str(iter_final_redchi)
+ status_html.value = (
+ f"Iterative correction "
+ f"complete. Reduced chi-square: ("
+ f"{old_str}) ---> ({new_str})"
+ )
+ # Clear the pending summary after showing it once
+ iter_summary_pending = False
+ else:
+ # Format values consistently, showing change when refitting
+ try:
+ old_str = (
+ f"{old_redchi:.4g}"
+ if old_redchi is not None
+ else None
+ )
+ except Exception:
+ old_str = (
+ str(old_redchi)
+ if old_redchi is not None
+ else None
+ )
+ try:
+ new_str = f"{new_redchi:.4g}"
+ except Exception:
+ new_str = str(new_redchi)
+ if old_redchi is not None:
+ status_html.value = (
+ f"Refit complete. "
+ f"Reduced chi-square: ("
+ f"{old_str}) ---> ({new_str})"
+ )
+ else:
+ status_html.value = (
+ f"Fit complete. "
+ f"Reduced chi-square: ("
+ f"{new_str})"
+ )
+ # Persist the new redchi so subsequent runs are treated as
+ # refits
+ try:
+ if np.isfinite(new_redchi):
+ last_redchi_by_idx[idx] = float(new_redchi)
+ except Exception:
+ # If np.isfinite is not available or new_redchi is not
+ # numeric, store raw
+ try:
+ last_redchi_by_idx[idx] = float(new_redchi)
+ except Exception:
+ last_redchi_by_idx[idx] = new_redchi
+ if not plot_ok:
+ # Also echo a note in the log output
+ _log_once(
+ "(Note: Plot update partially failed; re-run to refresh components.)"
+ )
+ except Exception:
+ if not iterating_in_progress:
+ status_html.value = (
+ "Fit complete."
+ )
+ try:
+ if np.isfinite(new_redchi):
+ last_redchi_by_idx[idx] = float(new_redchi)
+ else:
+ last_redchi_by_idx[idx] = new_redchi
+ except Exception:
+ last_redchi_by_idx[idx] = new_redchi
+ # Update Cancel Fit button visibility after this fit completes
+ try:
+ _update_cancel_fit_visibility()
+ except Exception:
+ pass
+ if update_controls and (not iterating_in_progress):
+ try:
+ _show_controls_after_fit_or_opt()
+ except Exception:
+ pass
+
+ _on_main_thread(_apply_results_on_ui)
+ # Ensure the Cancel Fit button hides after the worker fully ends
+ # by clearing the thread reference and scheduling a final UI update.
+ try:
+ fit_thread = None
+ except Exception:
+ pass
+ # Only hide at the end if not iterating/frozen
+ if update_controls and (not iterating_in_progress):
+ try:
+ _on_main_thread(_force_cancel_fit_hidden)
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_force_cancel_fit_hidden)
+ except Exception:
+ pass
+ # Mark fit complete (successful path)
+ try:
+ _finish_fit_guard()
+ except Exception:
+ pass
+ except KeyboardInterrupt:
+ # Cancellation requested
+ def _notify_cancel():
+ if not iterating_in_progress:
+ try:
+ status_html.value = (
+ "Fit cancelled."
+ )
+ except Exception:
+ _log_once("Fit cancelled.")
+ # Keep visible during iteration; outer loop will hide at end
+ try:
+ if iterating_in_progress or cancel_fit_btn_frozen:
+ _force_cancel_fit_shown()
+ else:
+ _force_cancel_fit_hidden()
+ except Exception:
+ pass
+ if update_controls and (not iterating_in_progress):
+ try:
+ _show_controls_after_fit_or_opt()
+ except Exception:
+ pass
+ try:
+ delete_peaks_btn.layout.display = ""
+ except Exception:
+ pass
+
+ _on_main_thread(_notify_cancel)
+ # Clear thread reference and trigger a final visibility update
+ try:
+ fit_thread = None
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_update_cancel_fit_visibility)
+ except Exception:
+ pass
+ # Mark fit completion after cancellation
+ try:
+ _finish_fit_guard()
+ except Exception:
+ pass
+ except Exception as e:
+
+ def _notify_error():
+ if not iterating_in_progress:
+ try:
+ status_html.value = (
+ f"Fit failed: {e}"
+ )
+ except Exception:
+ _log_once(f"Fit failed: {e}")
+ # Keep visible during iteration; final cleanup handles hide.
+ try:
+ if iterating_in_progress or cancel_fit_btn_frozen:
+ _force_cancel_fit_shown()
+ else:
+ _force_cancel_fit_hidden()
+ except Exception:
+ pass
+ if update_controls and (not iterating_in_progress):
+ # Restore controls hidden during Fit
+ try:
+ _show(fit_btn)
+ _show(add_peaks_btn)
+ _show(iter_btn)
+ _show(reset_all_row)
+ _show(save_btn)
+ _show(fit_range_row)
+ except Exception:
+ pass
+ try:
+ _show(canonize_btn)
+ _show(load_canon_btn)
+ except Exception:
+ pass
+ try:
+ delete_peaks_btn.layout.display = ""
+ except Exception:
+ pass
+
+ _on_main_thread(_notify_error)
+ # Clear thread reference and trigger a final visibility update
+ try:
+ fit_thread = None
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_update_cancel_fit_visibility)
+ except Exception:
+ pass
+ # Mark fit completion after error
+ try:
+ _finish_fit_guard()
+ except Exception:
+ pass
+
+ fit_thread = threading.Thread(target=_worker, daemon=True)
+ fit_thread.start()
+ if update_controls:
+ # Show the Cancel Fit button immediately when a fit starts (guard will be
+ # cleared only when the worker actually finishes to prevent overlapping fits).
+ try:
+ _force_cancel_fit_shown()
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_force_cancel_fit_shown)
+ except Exception:
+ try:
+ _update_cancel_fit_visibility()
+ except Exception:
+ pass
+ return None
+
+ # Track displayed spectrum independently for deconvolution
+ current_idx_deconv = None
+ cache_owner_idx = None
+
+ def _on_spectrum_change(*_):
+ nonlocal bulk_update_in_progress
+ nonlocal on_spectrum_change_inflight, last_on_spectrum_change_ts
+ nonlocal cache_owner_idx
+ nonlocal range_sliders
+ nonlocal adding_mode, new_peak_xs, new_peak_windows
+ nonlocal previous_in_range_indices
+ nonlocal xmin, xmax
+ nonlocal default_fit_range_value
+ nonlocal persisted_fit_ranges
+ # Debounce/guard: prevent rapid double invocation
+ try:
+ now_ts = time.time()
+ except Exception:
+ now_ts = 0.0
+ if on_spectrum_change_inflight:
+ return
+ if (now_ts - last_on_spectrum_change_ts) < 0.03:
+ return
+ on_spectrum_change_inflight = True
+ try:
+ idx = spectrum_sel.value
+ nonlocal current_idx_deconv
+ current_idx_deconv = idx
+ try:
+ _update_spectrum_counter()
+ except Exception:
+ pass
+ # Reset canonize confirmation UI on spectrum switch
+ try:
+ _show(canonize_btn)
+ _hide(canonize_confirm_btn)
+ _hide(canonize_cancel_btn)
+ except Exception:
+ pass
+ # Persist current Fit X-ranges before switching.
+ try:
+ persisted_fit_ranges = _current_fit_ranges()
+ except Exception:
+ pass
+
+ # Immediately clear the displayed peak list so no prior spectrum's peaks linger
+ # if something fails during rebuild.
+ try:
+ peak_controls_box.children = [widgets.HTML("Loading spectrum . . .")]
+ except Exception:
+ pass
+
+ # Hard reset any transient UI state so NOTHING carries over between spectra.
+ # New spectrum should initialize from defaults and the DataFrame only.
+ try:
+ # Use a fresh dict so cached widget objects cannot be reused.
+ global peak_box_cache
+ peak_box_cache = {}
+ except Exception:
+ pass
+ cache_owner_idx = None
+ try:
+ previous_in_range_indices = set()
+ except Exception:
+ pass
+ try:
+ peak_center_state_by_idx.clear()
+ except Exception:
+ pass
+ try:
+ last_result_by_idx.clear()
+ except Exception:
+ pass
+ try:
+ last_redchi_by_idx.clear()
+ except Exception:
+ pass
+ try:
+ included_index_map.clear()
+ except Exception:
+ pass
+
+ # Force-exit delete mode (if it was active) and clear any markers/staging.
+ try:
+ nonlocal deleting_mode
+ deleting_mode = False
+ except Exception:
+ pass
+ try:
+ staged_delete_indices.clear()
+ except Exception:
+ pass
+ try:
+ _clear_delete_peak_shapes()
+ except Exception:
+ pass
+ # Exit add-peak mode and clear any temporary markers
+ try:
+ adding_mode = False
+ new_peak_xs.clear()
+ new_peak_windows.clear()
+ except Exception:
+ pass
+ try:
+ _clear_add_peak_shapes()
+ except Exception:
+ pass
+
+ # Update x-span for this spectrum, then restore persisted Fit X-ranges (clamped).
+ try:
+ x_arr, y_arr = _get_xy(idx)
+ except Exception:
+ x_arr, y_arr = (None, None)
+ if x_arr is not None and getattr(x_arr, 'size', 0) > 0:
+ try:
+ xmin = float(np.nanmin(x_arr))
+ xmax = float(np.nanmax(x_arr))
+ if xmax < xmin:
+ xmin, xmax = xmax, xmin
+ except Exception:
+ pass
+ try:
+ default_fit_range_value = (float(xmin), float(xmax))
+ except Exception:
+ pass
+
+ # Avoid triggering expensive rebuilds while updating sliders.
+ bulk_prev = bulk_update_in_progress
+ bulk_update_in_progress = True
+ try:
+ _apply_ranges_to_sliders(persisted_fit_ranges, xmin, xmax)
+ finally:
+ bulk_update_in_progress = bulk_prev
+
+ # Update plot data for the new spectrum and clear any prior fit
+ try:
+ x_arr, y_arr = _get_xy(idx)
+ if x_arr is not None and y_arr is not None:
+ with fig.batch_update():
+ fig.data[0].x = x_arr.tolist()
+ fig.data[0].y = y_arr.tolist()
+ except Exception:
+ pass
+ try:
+ with fig.batch_update():
+ fig.data[1].x = []
+ fig.data[1].y = []
+ while len(fig.data) > 2:
+ fig.data = tuple(fig.data[:2])
+ except Exception:
+ pass
+
+ # Rebuild per-peak controls from scratch (defaults + DataFrame)
+ bulk_update_in_progress = True
+ try:
+ _refresh_peak_control_widgets(idx)
+ finally:
+ bulk_update_in_progress = False
+ # Refresh the fit range overlay for the new spectrum
+ try:
+ _update_fit_range_indicator()
+ except Exception:
+ pass
+ # Freeze y-axis to this spectrum's data range to reduce flicker on updates
+ try:
+ _fix_y_range(idx)
+ except Exception:
+ pass
+ # Clear any prior fit from plot; wait for user to click Fit
+ try:
+ with fig.batch_update():
+ fig.data[1].x = []
+ fig.data[1].y = []
+ while len(fig.data) > 2:
+ fig.data = tuple(fig.data[:2])
+ except Exception:
+ pass
+ try:
+ status_html.value = "Spectrum changed. Click Fit to compute."
+ except Exception:
+ pass
+ # Persist time selection to session state
+ try:
+ if idx is not None and "Time" in FTIR_DataFrame.columns:
+ _set_session_selection(time=FTIR_DataFrame.loc[idx].get("Time"))
+ except Exception:
+ pass
+ # Show mark row now that a spectrum is actively selected
+ try:
+ if 'mark_row' in locals() or 'mark_row' in globals():
+ mark_row.layout.display = ""
+ except Exception:
+ pass
+ finally:
+ on_spectrum_change_inflight = False
+ try:
+ last_on_spectrum_change_ts = time.time()
+ except Exception:
+ last_on_spectrum_change_ts = now_ts
+
+ # No range checkboxes to manage
+
+ def _save_for_file(b):
+ if _recent_click("save_for_file"):
+ return
+ idx = spectrum_sel.value
+ res = last_result_by_idx.get(idx)
+ # Require a Fit for the current spectrum before saving.
+ if res is None:
+ _log_once("No current fit. Click 'Fit' to compute, then click 'Save' again.")
+ return
+ # Only save parameters for peaks included in the most recent fit
+ all_peaks_x, _ = _get_peaks(idx)
+ state_for_save = peak_center_state_by_idx.get(idx, {})
+
+ def _resolve_original_peak_index(cb, pos: int):
+ """Return 0-based original peak index for a checkbox row."""
+ orig = getattr(cb, "_original_idx", None)
+ if orig is not None:
+ try:
+ return int(orig)
+ except Exception:
+ pass
+ # Fallback: parse from the visible label (e.g., "Include 19")
+ try:
+ import re
+
+ desc = str(getattr(cb, "description", ""))
+ m = re.search(r"(\d+)", desc)
+ if m:
+ # UI labels are 1-based
+ return max(0, int(m.group(1)) - 1)
+ except Exception:
+ pass
+ # Fallback: use the peak-index mapping list when available (in-range subset UIs)
+ try:
+ if pos < len(center_slider_peak_indices):
+ return int(center_slider_peak_indices[pos])
+ except Exception:
+ pass
+ return int(pos)
+
+ included_original = []
+ for pos, cb in enumerate(include_checkboxes):
+ try:
+ if not getattr(cb, "value", False):
+ continue
+ except Exception:
+ continue
+ try:
+ orig_idx = _resolve_original_peak_index(cb, pos)
+ except Exception:
+ orig_idx = pos
+ included_original.append(orig_idx)
+ if not included_original:
+ _log_once("No peaks selected. Select peaks then Save.")
+ return
+ # Preserve ordering by original peak index and remove duplicates
+ included_original = sorted(dict.fromkeys(included_original))
+
+ def _coerce_ranges(ranges_in):
+ """Return list of [lo, hi] floats for the current Fit X-ranges."""
+ out = []
+ if not ranges_in:
+ return out
+ for pair in ranges_in:
+ try:
+ lo_v, hi_v = pair
+ except Exception:
+ continue
+ try:
+ lo_f = float(lo_v)
+ hi_f = float(hi_v)
+ except Exception:
+ continue
+ try:
+ if 'np' in globals():
+ if not (bool(np.isfinite(lo_f)) and bool(np.isfinite(hi_f))):
+ continue
+ except Exception:
+ pass
+ if hi_f < lo_f:
+ lo_f, hi_f = hi_f, lo_f
+ out.append([lo_f, hi_f])
+ return out
+
+ try:
+ selected_x_ranges = _coerce_ranges(_current_fit_ranges())
+ except Exception:
+ selected_x_ranges = []
+
+ def _coerce_float(val):
+ try:
+ v = float(val)
+ except Exception:
+ return None
+ try:
+ if 'np' in globals():
+ if bool(np.isfinite(v)):
+ return v
+ return None
+ except Exception:
+ pass
+ try:
+ import math
+
+ if math.isfinite(v):
+ return v
+ except Exception:
+ pass
+ return None
+
+ def _slider_value_for(orig_idx: int, sliders, default=None):
+ """Return the slider.value corresponding to orig_idx, if available."""
+ try:
+ pos = center_slider_peak_indices.index(orig_idx)
+ except Exception:
+ return default
+ try:
+ return sliders[pos].value
+ except Exception:
+ return default
+
+ out = []
+ for orig_idx in included_original:
+ prefix = f"p{orig_idx}_"
+ d = {}
+ for name in ("amplitude", "center", "sigma", "fraction"):
+ p = res.params.get(prefix + name)
+ if p is not None:
+ try:
+ d[name] = float(p.value)
+ except Exception:
+ d[name] = p.value
+ peak_state = state_for_save.get(orig_idx, {})
+ initial_val = peak_state.get('initial')
+ user_val = peak_state.get('user')
+ fit_val = peak_state.get('fit')
+
+ if initial_val is None and orig_idx < len(all_peaks_x):
+ initial_val = all_peaks_x[orig_idx]
+
+ # Do not restore user centers from per-spectrum caches
+ if user_val is None:
+ try:
+ pos = center_slider_peak_indices.index(orig_idx)
+ user_val = center_sliders[pos].value
+ except Exception:
+ user_val = initial_val
+
+ if 'center' in d:
+ fit_val = d.get('center')
+ else:
+ if fit_val is None:
+ p_center = res.params.get(prefix + 'center')
+ if p_center is not None:
+ try:
+ fit_val = float(p_center.value)
+ d['center'] = fit_val
+ except Exception:
+ fit_val = p_center.value
+ elif fit_val is not None:
+ d['center'] = fit_val
+ if fit_val is None:
+ fit_val = user_val
+
+ coerced_initial = _coerce_float(initial_val)
+ coerced_user = _coerce_float(user_val)
+ coerced_fit = _coerce_float(fit_val)
+ # Persist only the fit-derived center; fall back to user or initial values
+ final_center = None
+ if coerced_fit is not None:
+ final_center = coerced_fit
+ elif fit_val is not None:
+ final_center = fit_val
+ elif coerced_user is not None:
+ final_center = coerced_user
+ elif user_val is not None:
+ final_center = user_val
+ elif coerced_initial is not None:
+ final_center = coerced_initial
+ elif initial_val is not None:
+ final_center = initial_val
+ if final_center is None and 'center' in d:
+ final_center = d['center']
+ if final_center is not None:
+ d['center'] = final_center
+
+ # Ensure sigma, alpha, and A are always saved.
+ # - lmfit uses 'fraction' for pseudo-Voigt Lorentz fraction; we expose it as 'alpha'
+ # - lmfit uses 'amplitude'; we persist it as 'A'
+ try:
+ sigma_fit = _coerce_float(d.get('sigma'))
+ except Exception:
+ sigma_fit = None
+ if sigma_fit is None:
+ sigma_fit = _coerce_float(_slider_value_for(orig_idx, sigma_sliders))
+ if sigma_fit is not None:
+ d['sigma'] = float(sigma_fit)
+
+ try:
+ alpha_fit = _coerce_float(d.get('fraction'))
+ except Exception:
+ alpha_fit = None
+ if alpha_fit is None:
+ alpha_fit = _coerce_float(d.get('alpha'))
+ if alpha_fit is None:
+ alpha_fit = _coerce_float(_slider_value_for(orig_idx, alpha_sliders))
+ if alpha_fit is not None:
+ # Keep both keys for compatibility
+ d['alpha'] = float(alpha_fit)
+ d['fraction'] = float(alpha_fit)
+
+ try:
+ amp_fit = _coerce_float(d.get('amplitude'))
+ except Exception:
+ amp_fit = None
+ if amp_fit is None:
+ amp_fit = _coerce_float(_slider_value_for(orig_idx, amplitude_sliders))
+ if amp_fit is not None:
+ d['A'] = float(amp_fit)
+ # Avoid saving redundant 'amplitude' alongside 'A'
+ try:
+ d.pop('amplitude', None)
+ except Exception:
+ pass
+ # Persist the original peak number (1-based, matches UI)
+ d['peak_number'] = int(orig_idx) + 1
+ out.append(d)
+ _persist_deconv_results(idx, out)
+ try:
+ _persist_deconv_x_ranges(idx, selected_x_ranges)
+ except Exception:
+ pass
+ try:
+ file_label = FTIR_DataFrame.loc[idx, "File Name"]
+ except Exception:
+ file_label = str(idx)
+ _log_once(
+ f"Saved deconvolution for file '{file_label}'. Stored results in DataFrame."
+ )
+ try:
+ _deconv_changes["saved"].append((idx, len(out)))
+ except Exception:
+ pass
+
+ def _close_ui(b):
+ global peak_box_cache, peak_accordion
+ nonlocal adding_mode, previous_in_range_indices
+ # Emit a session summary before closing widgets; keep log_html visible
+ try:
+ lines = _session_summary_lines(_deconv_changes, context="deconvolution")
+ _emit_session_summary(
+ log_html, lines, title="Session summary (Deconvolution)"
+ )
+ except Exception:
+ pass
+ # Signal cancellation and close widgets promptly
+ try:
+ cancel_event.set()
+ except Exception:
+ pass
+ # Reset add-peaks workflow state prior to tearing down widgets
+ try:
+ adding_mode = False
+ except Exception:
+ pass
+ try:
+ new_peak_xs.clear()
+ except Exception:
+ pass
+ try:
+ new_peak_windows.clear()
+ except Exception:
+ pass
+ # No shared cross-spectrum state to clear
+ try:
+ spectrum_sel.close()
+ material_dd.close()
+ conditions_dd.close()
+ include_bad_cb.close()
+ add_peaks_btn.close()
+ accept_new_peaks_btn.close()
+ redo_new_peaks_btn.close()
+ cancel_new_peaks_btn.close()
+ # Ensure iterative/cancel controls disappear on close
+ iter_btn.close()
+ cancel_fit_btn.close()
+ save_btn.close()
+ close_btn.close()
+ reset_all_btn.close()
+ # Close fit-range related widgets before clearing caches
+ for sl in list(range_sliders):
+ if hasattr(sl, "close"):
+ try:
+ sl.close()
+ except Exception:
+ pass
+ range_sliders.clear()
+ try:
+ range_sliders_box.close()
+ except Exception:
+ pass
+ try:
+ add_range_btn.close()
+ except Exception:
+ pass
+ try:
+ fit_range_row.close()
+ except Exception:
+ pass
+ # Safely close any parameter widgets (placeholders lack .close)
+ for lst in [alpha_sliders, center_sliders, sigma_sliders, amplitude_sliders, center_window_sliders, amplitude_mode_toggles, center_mode_toggles, sigma_mode_toggles, include_checkboxes]:
+ for w in lst:
+ if hasattr(w, "close"):
+ try:
+ w.close()
+ except Exception:
+ pass
+ # Close any cached peak boxes (handles lazy placeholders + materialized widgets)
+ try:
+ for entry in getattr(peak_box_cache, 'values', lambda: [])():
+ for k in ['box','toggle','details','include','alpha','center','sigma','amplitude','center_window','amp_mode','center_mode','sigma_mode']:
+ w = entry.get(k)
+ if hasattr(w, 'close'):
+ try:
+ w.close()
+ except Exception:
+ pass
+ except Exception:
+ pass
+ peak_controls_box.close()
+ try:
+ peak_controls_section.close()
+ except Exception:
+ pass
+ try:
+ excluded_peaks_html.close()
+ except Exception:
+ pass
+ try:
+ mark_bad_btn.close()
+ except Exception:
+ pass
+ try:
+ mark_good_btn.close()
+ except Exception:
+ pass
+ try:
+ mark_row.close()
+ except Exception:
+ pass
+ try:
+ status_row.close()
+ except Exception:
+ pass
+ try:
+ optimize_status_html.close()
+ except Exception:
+ pass
+ try:
+ add_peaks_slider.close()
+ except Exception:
+ pass
+ try:
+ add_peaks_text.close()
+ except Exception:
+ pass
+ try:
+ add_peaks_add_btn.close()
+ except Exception:
+ pass
+ try:
+ colab_add_row.close()
+ except Exception:
+ pass
+ try:
+ colab_add_help.close()
+ except Exception:
+ pass
+ # Close the main UI container and status label so no stray widgets remain
+ try:
+ status_html.close()
+ except Exception:
+ pass
+ try:
+ ui.close()
+ except Exception:
+ pass
+ # Leave the log widget displayed so the last message remains visible
+ fig.close()
+ except Exception:
+ pass
+ # Reset peak-related state so a fresh invocation reconstructs everything
+ try:
+ alpha_sliders[:] = []
+ center_sliders[:] = []
+ sigma_sliders[:] = []
+ amplitude_sliders[:] = []
+ center_window_sliders[:] = []
+ include_checkboxes[:] = []
+ amplitude_mode_toggles[:] = []
+ center_mode_toggles[:] = []
+ sigma_mode_toggles[:] = []
+ center_slider_peak_indices[:] = []
+ except Exception:
+ pass
+ try:
+ if isinstance(peak_box_cache, dict):
+ peak_box_cache.clear()
+ except Exception:
+ pass
+ try:
+ peak_box_cache = {}
+ except Exception:
+ pass
+ try:
+ peak_accordion = None
+ except Exception:
+ pass
+ try:
+ peak_center_state_by_idx.clear()
+ except Exception:
+ pass
+ try:
+ last_result_by_idx.clear()
+ except Exception:
+ pass
+ try:
+ last_redchi_by_idx.clear()
+ except Exception:
+ pass
+ try:
+ included_index_map.clear()
+ except Exception:
+ pass
+ try:
+ peak_label_widgets.clear()
+ original_peak_centers.clear()
+ last_active_ranges.clear()
+ except Exception:
+ pass
+ try:
+ previous_in_range_indices = set()
+ except Exception:
+ pass
+ try:
+ last_click_ts.clear()
+ except Exception:
+ pass
+ try:
+ globals().pop('_refresh_slider_lists', None)
+ except Exception:
+ pass
+ # Clear fit guard so next session can start fitting
+ try:
+ fit_update_inflight = False
+ except Exception:
+ pass
+
+ # Wire events
+ spectrum_sel.observe(_on_spectrum_change, names="value")
+ material_dd.observe(_rebuild_spectrum_options, names="value")
+ conditions_dd.observe(_rebuild_spectrum_options, names="value")
+
+ # Persist material/conditions selections
+ def _persist_pd_filters(_=None):
+ try:
+ _set_session_selection(
+ material=material_dd.value, conditions=conditions_dd.value
+ )
+ except Exception:
+ pass
+
+ material_dd.observe(_persist_pd_filters, names="value")
+ conditions_dd.observe(_persist_pd_filters, names="value")
+ # Observers
+ # Observe all dynamic range sliders
+ try:
+ fit_range.observe(_on_fit_range_change, names="value")
+ except Exception:
+ pass
+
+ # Wire reset buttons
+ def _reset_all(_b=None):
+ nonlocal bulk_update_in_progress
+ bulk_update_in_progress = True
+ try:
+ lo, hi = default_fit_range_value
+ fit_range.value = [float(lo), float(hi)]
+ except Exception:
+ pass
+ # Reset per-peak controls
+ try:
+ for cb in include_checkboxes:
+ cb.value = DEFAULT_INCLUDE
+ except Exception:
+ pass
+ try:
+ for s in alpha_sliders:
+ s.value = DEFAULT_ALPHA
+ except Exception:
+ pass
+ try:
+ for s in center_sliders:
+ # Reset center to its detected peak position stored in attribute if available; fallback to current
+ pass # center sliders retain current value
+ except Exception:
+ pass
+ try:
+ for s in center_window_sliders:
+ s.value = float(PER_PEAK_DEFAULT_CENTER_WINDOW)
+ except Exception:
+ pass
+ try:
+ for s in sigma_sliders:
+ s.value = float(PER_PEAK_DEFAULT_SIGMA)
+ except Exception:
+ pass
+ try:
+ for s in amplitude_sliders:
+ # Do not recompute default; keep current amplitude as starting point
+ pass
+ except Exception:
+ pass
+ try:
+ for tb in amplitude_mode_toggles:
+ tb.value = 'Auto'
+ for tb in center_mode_toggles:
+ tb.value = CENTER_MODE_WINDOW
+ for tb in sigma_mode_toggles:
+ tb.value = 'Auto'
+ except Exception:
+ pass
+ _snapshot_current_controls()
+ bulk_update_in_progress = False
+ try:
+ status_html.value = "All peak parameters reset. Click Fit to update."
+ except Exception:
+ pass
+ reset_all_btn.on_click(_reset_all)
+
+ def _on_fit_click(_b=None):
+ # Always allow fit to start, regardless of parameter mode
+ if _recent_click("fit"):
+ return
+ # Show Cancel Fit button immediately
+ try:
+ _set_cancel_button_mode("fit")
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_force_cancel_fit_shown)
+ except Exception:
+ try:
+ _update_cancel_fit_visibility()
+ except Exception:
+ pass
+ _fit_and_update_plot()
+
+ fit_btn.on_click(_on_fit_click)
+ save_btn.on_click(_save_for_file)
+ close_btn.on_click(_close_ui)
+
+ # Helper: quietly set a widget attribute without triggering control-change side effects
+ def _set_quiet(widget, attr, value):
+ """Set a widget attribute while suppressing observers (thread-safe)."""
+ nonlocal bulk_update_in_progress
+
+ def _assign():
+ nonlocal bulk_update_in_progress
+ bulk_update_in_progress = True
+ try:
+ setattr(widget, attr, value)
+ except Exception:
+ pass
+ finally:
+ bulk_update_in_progress = False
+
+ try:
+ if threading.current_thread() is threading.main_thread():
+ _assign()
+ return
+ except Exception:
+ pass
+
+ done_event = threading.Event()
+
+ def _wrapped():
+ try:
+ _assign()
+ finally:
+ try:
+ done_event.set()
+ except Exception:
+ pass
+
+ try:
+ _on_main_thread(_wrapped)
+ except Exception:
+ _wrapped()
+ return
+
+ try:
+ done_event.wait(timeout=2.0)
+ except Exception:
+ pass
+
+ # Fix y-axis range to the current data to prevent autoscale flicker during updates
+ def _fix_y_range(idx):
+ try:
+ x_arr, y_arr = _get_xy(idx)
+ except Exception:
+ x_arr, y_arr = None, None
+ if y_arr is None:
+ return
+ try:
+ y0_min = float(np.nanmin(y_arr))
+ y0_max = float(np.nanmax(y_arr))
+ except Exception:
+ return
+ try:
+ with fig.batch_update():
+ fig.update_yaxes(autorange=False, range=[y0_min, y0_max])
+ except Exception:
+ pass
+
+ def _iteratively_correct_worker():
+ """Coordinate-descent style tuning of parameters to reduce reduced chi-square.
+
+ Iterates over per-peak α sliders (for included peaks), the center window, and
+ the initial sigma, trying +/- step changes one parameter at a time. Keeps a
+ change only if reduced chi-square improves. Stops when a full sweep makes no
+ improvements, or after a safety cap of sweeps.
+ """
+
+ nonlocal iterating_in_progress, iter_start_redchi
+ nonlocal iter_final_redchi, iter_summary_pending
+ nonlocal cancel_fit_btn_frozen, fit_thread, fit_update_inflight
+
+ idx = spectrum_sel.value
+
+ FIT_WAIT_TIMEOUT = 40.0 # seconds
+ FIT_WAIT_POLL_INTERVAL = 0.1
+ iteration_timed_out = False
+ iteration_timeout_message = ""
+
+ def _sanitize_ranges(ranges_in):
+ cleaned = []
+ if not ranges_in:
+ return cleaned
+ has_np = 'np' in globals()
+ for pair in ranges_in:
+ try:
+ lo, hi = pair
+ lo_f = float(lo)
+ hi_f = float(hi)
+ except Exception:
+ continue
+ finite_ok = True
+ if has_np:
+ try:
+ finite_ok = bool(np.isfinite(lo_f)) and bool(np.isfinite(hi_f))
+ except Exception:
+ finite_ok = True
+ if not finite_ok:
+ continue
+ if hi_f < lo_f:
+ lo_f, hi_f = hi_f, lo_f
+ cleaned.append((lo_f, hi_f))
+ return cleaned
+
+ try:
+ fit_ranges_snapshot = _sanitize_ranges(_current_fit_ranges())
+ except Exception:
+ fit_ranges_snapshot = []
+ try:
+ _debug_log(f"[ITER_RANGE_SNAPSHOT] ranges={fit_ranges_snapshot}")
+ except Exception:
+ pass
+
+ def _wait_for_fit_idle(max_wait=FIT_WAIT_TIMEOUT, *, reason: str = "fit to finish"):
+ """Wait until no fit thread is active and the guard is clear.
+
+ Returns True when idle, False on timeout, and None if cancellation is requested.
+ """
+ try:
+ start_ts = time.time()
+ except Exception:
+ start_ts = 0.0
+ while True:
+ try:
+ if cancel_event.is_set():
+ return None
+ except Exception:
+ pass
+ guard_active = False
+ try:
+ guard_active = bool(fit_update_inflight)
+ except Exception:
+ guard_active = False
+ thread_active = False
+ try:
+ th = fit_thread
+ thread_active = th is not None and th.is_alive()
+ except Exception:
+ thread_active = False
+ if not guard_active and not thread_active:
+ return True
+ if max_wait is not None:
+ try:
+ now_ts = time.time()
+ except Exception:
+ now_ts = start_ts
+ if (now_ts - start_ts) >= max_wait:
+ return False
+ try:
+ time.sleep(FIT_WAIT_POLL_INTERVAL)
+ except Exception:
+ break
+ return False
+
+ # Helper: run fit synchronously and return last redchi
+ def _run_fit_and_wait(force_ranges=None):
+ nonlocal iteration_timed_out, iteration_timeout_message
+ # If cancellation is already requested, don't start a new fit
+ try:
+ if cancel_event.is_set():
+ return np.inf
+ except Exception:
+ pass
+ local_ranges = force_ranges
+ if not local_ranges:
+ try:
+ local_ranges = _sanitize_ranges(_current_fit_ranges())
+ except Exception:
+ local_ranges = []
+ wait_prev = _wait_for_fit_idle(reason="previous fit to finish")
+ if wait_prev is False:
+ msg_prev = "Timed out waiting for previous fit to finish. Optimization stopped."
+ iteration_timed_out = True
+ iteration_timeout_message = msg_prev
+ _log_once(msg_prev)
+ try:
+ status_html.value = f"{msg_prev}"
+ except Exception:
+ pass
+ try:
+ cancel_event.set()
+ except Exception:
+ pass
+ return np.inf
+ if wait_prev is None:
+ return np.inf
+ override_ranges = list(local_ranges) if local_ranges else None
+ _fit_and_update_plot(
+ ignore_debounce=True,
+ override_ranges=override_ranges,
+ update_plot=False,
+ update_controls=False,
+ )
+ wait_current = _wait_for_fit_idle(reason="fit to finish")
+ if wait_current is False:
+ msg_curr = "Timed out waiting for fit to finish. Optimization stopped."
+ iteration_timed_out = True
+ iteration_timeout_message = msg_curr
+ _log_once(msg_curr)
+ try:
+ status_html.value = f"{msg_curr}"
+ except Exception:
+ pass
+ try:
+ cancel_event.set()
+ except Exception:
+ pass
+ return np.inf
+ if wait_current is None:
+ return np.inf
+ # Prefer the most recent lmfit result (set inside the worker thread)
+ try:
+ res_obj = last_result_by_idx.get(idx)
+ except Exception:
+ res_obj = None
+ if res_obj is not None:
+ try:
+ rc_val = getattr(res_obj, "redchi", np.inf)
+ except Exception:
+ rc_val = np.inf
+ else:
+ rc_val = last_redchi_by_idx.get(idx, np.inf)
+ try:
+ rc_val = float(rc_val)
+ except Exception:
+ rc_val = np.inf
+ if not np.isfinite(rc_val):
+ # Treat non-finite reduced chi-square as a failed fit for iteration purposes
+ return np.inf
+ return rc_val
+
+ # Establish baseline reduced chi-square from snapshot taken at click time.
+ # Fall back to one quick fit if no prior value exists.
+ start_rc = iter_start_redchi
+ try:
+ start_rc = float(start_rc)
+ except Exception:
+ start_rc = np.inf
+ if not np.isfinite(start_rc):
+ # No prior redchi recorded; compute once.
+ try:
+ status_html.value = "Iteratively correcting (pre-fit)..."
+ except Exception:
+ pass
+ start_rc = _run_fit_and_wait(fit_ranges_snapshot)
+ base_rc = start_rc
+ # Iteration change counter: increments whenever a parameter change is kept
+ iteration_changes = 0
+ # Minimal running status; will update the counter on each kept change
+ try:
+ status_html.value = (
+ "iterating... (iterations so far: 0)"
+ )
+ except Exception:
+ pass
+ try:
+ if cancel_event.is_set():
+ # Show old -> current comparison on cancel
+ try:
+ old_str = f"{start_rc:.4g}"
+ except Exception:
+ old_str = str(start_rc)
+ try:
+ new_str = f"{base_rc:.4g}"
+ except Exception:
+ new_str = str(base_rc)
+ try:
+ status_html.value = (
+ f"Iterative correction cancelled. "
+ f"Reduced chi-square: ({old_str}) ---> ({new_str})"
+ )
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_update_cancel_fit_visibility)
+ except Exception:
+ pass
+ # Allow normal fit status updates again; unfreeze and hide now
+ iterating_in_progress = False
+ try:
+ cancel_fit_btn_frozen = False
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_force_cancel_fit_hidden)
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_show_controls_after_fit_or_opt)
+ except Exception:
+ try:
+ _show_controls_after_fit_or_opt()
+ except Exception:
+ pass
+ return
+ except Exception:
+ pass
+ if not np.isfinite(base_rc):
+ base_rc = _run_fit_and_wait(fit_ranges_snapshot)
+ if not np.isfinite(base_rc):
+ base_rc = np.inf
+
+ def _active_alpha_targets():
+ targets = []
+ try:
+ ensure_len = len(include_checkboxes)
+ except Exception:
+ ensure_len = 0
+ for pos in range(ensure_len):
+ cb = include_checkboxes[pos]
+ include_flag = False
+ try:
+ include_flag = bool(getattr(cb, "value", False))
+ except Exception:
+ include_flag = False
+ if not include_flag:
+ continue
+ slider = None
+ try:
+ if pos < len(alpha_sliders):
+ slider = alpha_sliders[pos]
+ except Exception:
+ slider = None
+ if slider is None or not hasattr(slider, "value"):
+ continue
+ try:
+ float(slider.value)
+ except Exception:
+ continue
+ peak_idx = None
+ try:
+ peak_idx = getattr(cb, "_original_idx")
+ except Exception:
+ peak_idx = None
+ if peak_idx is None and center_slider_peak_indices:
+ try:
+ if pos < len(center_slider_peak_indices):
+ peak_idx = center_slider_peak_indices[pos]
+ except Exception:
+ peak_idx = None
+ targets.append({"pos": pos, "slider": slider, "peak_idx": peak_idx})
+ return targets
+
+ alpha_targets = _active_alpha_targets()
+ if not alpha_targets:
+ try:
+ status_html.value = (
+ "Cannot iterate: select at least one in-range peak with 'Include peak in Fit'."
+ )
+ except Exception:
+ _log_once("Cannot iterate: no included peaks within the current fit range.")
+ try:
+ iterating_in_progress = False
+ cancel_fit_btn_frozen = False
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_force_cancel_fit_hidden)
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_show_controls_after_fit_or_opt)
+ except Exception:
+ try:
+ _show_controls_after_fit_or_opt()
+ except Exception:
+ pass
+ return
+
+ def _clamp(val, lo, hi):
+ try:
+ return max(lo, min(hi, val))
+ except Exception:
+ return val
+
+ def _ensure_real_slider(target):
+ slider = target.get("slider")
+ if slider is not None and not isinstance(slider, (_LazyPlaceholder, _LazyModePlaceholder)):
+ return
+ peak_idx = target.get("peak_idx")
+ if peak_idx is None:
+ return
+ entry = None
+ try:
+ if isinstance(peak_box_cache, dict):
+ entry = peak_box_cache.get(peak_idx)
+ except Exception:
+ entry = None
+ if not entry:
+ try:
+ _ensure_cache_from_accordion(peak_idx)
+ if isinstance(peak_box_cache, dict):
+ entry = peak_box_cache.get(peak_idx)
+ except Exception:
+ entry = None
+ if not entry:
+ return
+ if not entry.get('materialized'):
+ toggle = entry.get('toggle')
+ if toggle is not None:
+ toggle_ready = threading.Event()
+
+ def _open_toggle():
+ try:
+ toggle.value = True
+ except Exception:
+ pass
+ finally:
+ toggle_ready.set()
+
+ _on_main_thread(_open_toggle)
+ try:
+ toggle_ready.wait(timeout=1.5)
+ except Exception:
+ pass
+ try:
+ for _ in range(40):
+ try:
+ time.sleep(0.05)
+ except Exception:
+ pass
+ if isinstance(peak_box_cache, dict):
+ entry = peak_box_cache.get(peak_idx)
+ if entry and entry.get('materialized'):
+ break
+ except Exception:
+ pass
+ if not entry or not entry.get('materialized'):
+ return
+ real_slider = entry.get('alpha')
+ if real_slider is not None:
+ target['slider'] = real_slider
+ pos = target.get('pos')
+ try:
+ if pos is not None and pos < len(alpha_sliders):
+ alpha_sliders[pos] = real_slider
+ except Exception:
+ pass
+ real_include = entry.get('include')
+ if real_include is not None:
+ pos = target.get('pos')
+ try:
+ if pos is not None and pos < len(include_checkboxes):
+ include_checkboxes[pos] = real_include
+ except Exception:
+ pass
+
+ for tgt in alpha_targets:
+ try:
+ _ensure_real_slider(tgt)
+ except Exception:
+ pass
+
+ optimizable_targets = []
+ for tgt in alpha_targets:
+ locked = False
+ try:
+ pos = tgt.get("pos")
+ if pos is not None and pos < len(lock_alpha_checkboxes):
+ locked = bool(getattr(lock_alpha_checkboxes[pos], "value", False))
+ except Exception:
+ locked = False
+ if not locked:
+ optimizable_targets.append(tgt)
+
+ num_targets = len(optimizable_targets)
+ if num_targets == 0:
+ try:
+ status_html.value = (
+ "Cannot iterate: all peaks within range are locked."
+ )
+ except Exception:
+ pass
+ try:
+ iterating_in_progress = False
+ cancel_fit_btn_frozen = False
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_force_cancel_fit_hidden)
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_show_controls_after_fit_or_opt)
+ except Exception:
+ try:
+ _show_controls_after_fit_or_opt()
+ except Exception:
+ pass
+ return
+
+ current_rc = base_rc
+ if not np.isfinite(current_rc):
+ try:
+ status_html.value = "Iteratively correcting (pre-fit)..."
+ except Exception:
+ pass
+ current_rc = _run_fit_and_wait(fit_ranges_snapshot)
+ if not np.isfinite(current_rc):
+ base_rc = current_rc
+ try:
+ status_html.value = (
+ "Unable to start optimization: fit did not produce a finite reduced chi-square."
+ )
+ except Exception:
+ pass
+ try:
+ iterating_in_progress = False
+ cancel_fit_btn_frozen = False
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_force_cancel_fit_hidden)
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_show_controls_after_fit_or_opt)
+ except Exception:
+ try:
+ _show_controls_after_fit_or_opt()
+ except Exception:
+ pass
+ return
+
+ improvement_threshold = 1e-6
+ step_sequence = [0.1, 0.05]
+ max_sweeps = 12
+ total_evaluations = 0
+ changed_peak_indices = set()
+
+ def _update_iter_status(msg):
+ try:
+ status_html.value = msg
+ except Exception:
+ _log_once(html.unescape(msg) if isinstance(msg, str) else str(msg))
+
+ def _clamp_alpha(val):
+ try:
+ return max(0.0, min(1.0, float(val)))
+ except Exception:
+ return val
+
+ def _try_directional_alpha(slider, current_val, step, current_rc_local):
+ """Try +/-step once to choose direction, then keep stepping until no improvement."""
+ nonlocal total_evaluations
+ if slider is None or not hasattr(slider, "value"):
+ return current_val, current_rc_local, False
+
+ best_val = current_val
+ best_rc = current_rc_local
+ chosen_dir = 0.0
+
+ # First decision: compare +step vs -step
+ for direction in (step, -step):
+ cand = _clamp_alpha(current_val + direction)
+ if abs(cand - current_val) < 1e-9:
+ continue
+ _set_quiet(slider, "value", cand)
+ rc = _run_fit_and_wait(fit_ranges_snapshot)
+ total_evaluations += 1
+ if not np.isfinite(rc):
+ rc = np.inf
+ if rc + improvement_threshold < best_rc:
+ best_rc = rc
+ best_val = cand
+ chosen_dir = direction
+
+ # No improvement at this step size
+ if chosen_dir == 0.0 or abs(best_val - current_val) < 1e-12:
+ _set_quiet(slider, "value", current_val)
+ return current_val, current_rc_local, False
+
+ # Accept best direction and keep stepping while improving
+ current_val = best_val
+ current_rc_local = best_rc
+ _set_quiet(slider, "value", current_val)
+
+ while True:
+ try:
+ if cancel_event.is_set():
+ break
+ except Exception:
+ pass
+ cand = _clamp_alpha(current_val + chosen_dir)
+ if abs(cand - current_val) < 1e-9:
+ break
+ _set_quiet(slider, "value", cand)
+ rc = _run_fit_and_wait(fit_ranges_snapshot)
+ total_evaluations += 1
+ if not np.isfinite(rc):
+ rc = np.inf
+ if rc + improvement_threshold < current_rc_local:
+ current_val = cand
+ current_rc_local = rc
+ continue
+ # Revert and stop when no improvement
+ _set_quiet(slider, "value", current_val)
+ break
+
+ return current_val, current_rc_local, True
+
+ sweep = 0
+ while True:
+ try:
+ if cancel_event.is_set():
+ break
+ except Exception:
+ pass
+ sweep += 1
+ sweep_changed = False
+ for idx_target, target in enumerate(optimizable_targets, start=1):
+ try:
+ if cancel_event.is_set():
+ break
+ except Exception:
+ pass
+ slider = target.get("slider")
+ if slider is None or not hasattr(slider, "value"):
+ continue
+ try:
+ current_val = float(slider.value)
+ except Exception:
+ current_val = 0.5
+ original_val = current_val
+ peak_idx = target.get("peak_idx")
+
+ for step in step_sequence:
+ try:
+ if cancel_event.is_set():
+ break
+ except Exception:
+ pass
+ new_val, new_rc, improved = _try_directional_alpha(
+ slider, current_val, step, current_rc
+ )
+ if improved and (new_rc + improvement_threshold < current_rc):
+ current_val = new_val
+ current_rc = new_rc
+ sweep_changed = True
+ idx_key = peak_idx if peak_idx is not None else target.get("pos")
+ if idx_key is not None:
+ changed_peak_indices.add(idx_key)
+ try:
+ _update_iter_status(
+ f"iterating... sweep {sweep} | peak {idx_target}/{num_targets} | evaluations={total_evaluations} | α={current_val:.3f} | redχ={current_rc:.4g}"
+ )
+ except Exception:
+ pass
+ continue
+ # No improvement at this step size; try next smaller step
+ _set_quiet(slider, "value", current_val)
+ _set_quiet(slider, "value", current_val)
+ if cancel_event.is_set():
+ break
+
+ if cancel_event.is_set():
+ break
+ if not sweep_changed:
+ break
+ if sweep >= max_sweeps:
+ _log_once("Iteration sweep limit reached; stopping to avoid infinite loop.")
+ break
+
+ changed_peaks = len(changed_peak_indices)
+ iteration_changes = changed_peaks
+ base_rc = current_rc
+ try:
+ _snapshot_current_controls()
+ except Exception:
+ pass
+
+ # Final status: show old -> new comparison
+ try:
+ _snapshot_current_controls()
+ except Exception:
+ pass
+ try:
+ old_str = f"{start_rc:.4g}"
+ except Exception:
+ old_str = str(start_rc)
+ try:
+ new_str = f"{base_rc:.4g}"
+ except Exception:
+ new_str = str(base_rc)
+ try:
+ if cancel_event.is_set():
+ prefix = "Iterative correction cancelled."
+ if iteration_timed_out and iteration_timeout_message:
+ prefix = iteration_timeout_message.strip()
+ status_html.value = (
+ f"{prefix} Reduced chi-square: "
+ f"({old_str}) ---> ({new_str}) | peaks adjusted: {changed_peaks}/{num_targets} | evaluations: {total_evaluations}"
+ )
+ else:
+ status_html.value = (
+ f"Iterative correction complete. "
+ f"Reduced chi-square: ({old_str}) ---> ({new_str}) | peaks adjusted: {changed_peaks}/{num_targets} | evaluations: {total_evaluations}"
+ )
+ except Exception:
+ if cancel_event.is_set():
+ prefix = "Iterative correction cancelled."
+ if iteration_timed_out and iteration_timeout_message:
+ prefix = iteration_timeout_message.strip()
+ _log_once(
+ f"{prefix} Reduced chi-square: ({old_str}) -> ({new_str}) | peaks adjusted: {changed_peaks}/{num_targets} | evaluations: {total_evaluations}"
+ )
+ else:
+ _log_once(
+ f"Iterative correction complete. Reduced chi-square: ("
+ f"{old_str}) -> ({new_str}) | peaks adjusted: {changed_peaks}/{num_targets} | evaluations: {total_evaluations}"
+ )
+ # Persist iteration summary for session-level reporting
+ try:
+ idx_snapshot = spectrum_sel.value
+ if idx_snapshot is not None:
+ def _normalize_rc(val):
+ try:
+ if isinstance(val, (int, float)) and math.isfinite(val):
+ return float(val)
+ except Exception:
+ pass
+ try:
+ return float(val)
+ except Exception:
+ return val
+
+ _deconv_changes["iter"].append(
+ (
+ idx_snapshot,
+ _normalize_rc(start_rc),
+ _normalize_rc(base_rc),
+ int(changed_peaks),
+ )
+ )
+ except Exception:
+ pass
+ # Remember iteration summary for the next refit message
+ iter_final_redchi = base_rc
+ iter_summary_pending = True
+
+ # Allow normal fit status updates again and unfreeze button visibility.
+ # Perform the hide only once here to prevent mid-loop flicker.
+ iterating_in_progress = False
+ cancel_fit_btn_frozen = False
+ try:
+ _on_main_thread(_force_cancel_fit_hidden)
+ except Exception:
+ pass
+
+ # One final visible refresh (silent evaluations do not update the plot)
+ try:
+ _fit_and_update_plot(
+ ignore_debounce=True,
+ override_ranges=fit_ranges_snapshot,
+ update_plot=True,
+ update_controls=True,
+ )
+ except Exception:
+ pass
+
+ # Wire the iterative correct to run in background and support cancellation
+ def _on_iteratively_correct_click(b):
+ if _recent_click("iteratively_correct"):
+ return
+ nonlocal iter_thread, iterating_in_progress, cancel_event, iter_start_redchi, cancel_fit_btn_frozen
+ try:
+ if iter_thread is not None and iter_thread.is_alive():
+ try:
+ status_html.value = (
+ f"Iterative correction"
+ f" is already running."
+ )
+ except Exception:
+ pass
+ return
+ except Exception:
+ pass
+ # Snapshot current redchi for this spectrum at the moment of click
+ try:
+ idx_snapshot = spectrum_sel.value
+ iter_start_redchi = last_redchi_by_idx.get(idx_snapshot, np.inf)
+ except Exception:
+ iter_start_redchi = np.inf
+ # Reset cancel flag and mark iteration as active
+ try:
+ cancel_event.clear()
+ except Exception:
+ pass
+ iterating_in_progress = True
+ cancel_fit_btn_frozen = True
+ # Hide the same controls as during Fit while optimization runs
+ try:
+ _hide_controls_during_fit_or_opt()
+ except Exception:
+ pass
+ try:
+ _set_cancel_button_mode("optimize")
+ except Exception:
+ pass
+ try:
+ status_html.value = (
+ "Starting iterative correction..."
+ )
+ except Exception:
+ pass
+ try:
+ _force_cancel_fit_shown()
+ except Exception:
+ pass
+ iter_thread = threading.Thread(target=_iteratively_correct_worker, daemon=True)
+ iter_thread.start()
+ try:
+ _force_cancel_fit_shown()
+ except Exception:
+ pass
+ try:
+ _on_main_thread(_force_cancel_fit_shown)
+ except Exception:
+ try:
+ _update_cancel_fit_visibility()
+ except Exception:
+ pass
+
+ iter_btn.on_click(_on_iteratively_correct_click)
+
+ def _on_cancel_fit(b):
+ if _recent_click("cancel_fit"):
+ return
+ # Signal cancellation for any active fit/iteration
+ try:
+ cancel_event.set()
+ except Exception:
+ pass
+ try:
+ if fit_cancel_token is not None:
+ fit_cancel_token.set()
+ except Exception:
+ pass
+ try:
+ status_html.value = (
+ "Cancellation requested..."
+ )
+ except Exception:
+ pass
+ # Keep visibility consistent; it will auto-hide when work stops
+ try:
+ _update_cancel_fit_visibility()
+ except Exception:
+ pass
+
+ cancel_fit_btn.on_click(_on_cancel_fit)
+
+ def _on_mark_bad_click(_b=None):
+ try:
+ idx = spectrum_sel.value
+ qcol = _quality_column_name(FTIR_DataFrame)
+ FTIR_DataFrame.at[idx, qcol] = "bad"
+ try:
+ status_html.value = (
+ f"Marked row {idx} as bad quality."
+ )
+ except Exception:
+ pass
+ # Rebuild spectrum options to drop the bad row
+ try:
+ _rebuild_spectrum_options()
+ except Exception:
+ pass
+ except Exception:
+ pass
+ try:
+ _refresh_mark_buttons()
+ except Exception:
+ pass
+
+ # Defer wiring mark_bad_btn until after it's instantiated below
+
+ # Layout
+ controls_row_filters = widgets.HBox(
+ [material_dd, conditions_dd, include_bad_cb],
+ layout=widgets.Layout(align_items="center"),
+ )
+ controls_row_spectrum = widgets.HBox(
+ [spectrum_sel, prev_spectrum_btn, next_spectrum_btn, spectrum_counter],
+ layout=widgets.Layout(align_items="center"),
+ )
+ # We'll place the Fit X-ranges section AFTER the primary action rows
+ fit_range_row = widgets.VBox([
+ widgets.HTML("Fit X-ranges"),
+ range_sliders_box,
+ widgets.HBox([add_range_btn]),
+ ])
+ # Keep other global parameters grouped below the peak controls
+ reset_all_row = widgets.HBox([reset_all_btn])
+ # Mark buttons (use shared helper for mutually exclusive controls)
+ mark_bad_btn, mark_good_btn, _refresh_mark_buttons = _make_quality_controls(
+ FTIR_DataFrame,
+ lambda: (
+ FTIR_DataFrame.loc[current_idx_deconv]
+ if current_idx_deconv is not None
+ else None
+ ),
+ margin="0 8px 0 0",
+ )
+
+ # Add additional status and list refresh after helper toggles quality
+ def _post_mark_update_deconv(status: str):
+ nonlocal current_idx_deconv
+ try:
+ idx = current_idx_deconv
+ if status == "bad":
+ try:
+ status_html.value = f"Marked row {idx} as bad quality."
+ except Exception:
+ pass
+ else:
+ try:
+ status_html.value = f"Marked row {idx} as good quality."
+ except Exception:
+ pass
+ # Removal/reinsertion logic delegated to centralized helper to avoid flicker
+ if idx is not None:
+ try:
+ if status == "bad":
+ current_idx_deconv = idx
+ _quality_dropdown_handle(
+ status,
+ dropdown=spectrum_sel,
+ include_bad_flag=include_bad_cb.value,
+ idx=idx,
+ label_builder=lambda i: f"{FTIR_DataFrame.loc[i].get('Material','?')} | {FTIR_DataFrame.loc[i].get('Conditions', FTIR_DataFrame.loc[i].get('Condition','?'))} | {FTIR_DataFrame.loc[i].get('File Name','?')}",
+ observer_fn=_on_spectrum_change,
+ )
+ except Exception:
+ pass
+ except Exception:
+ pass
+ try:
+ _refresh_mark_buttons()
+ except Exception:
+ pass
+ try:
+ _deconv_changes["quality"].append((current_idx_deconv, status))
+ except Exception:
+ pass
+
+ mark_bad_btn.on_click(lambda _b=None: _post_mark_update_deconv("bad"))
+ mark_good_btn.on_click(lambda _b=None: _post_mark_update_deconv("good"))
+ mark_row = widgets.HBox([mark_bad_btn, mark_good_btn])
+ # Hide mark buttons until a spectrum is selected; will show on selection
+ try:
+ mark_row.layout.display = "none"
+ except Exception:
+ pass
+
+ # Refresh function provided by helper
+
+ # Three action rows before Fit X-ranges
+ primary_actions_row = widgets.HBox(
+ [fit_btn, save_btn, close_btn],
+ layout=widgets.Layout(
+ flex_flow="row wrap", align_items="center", justify_content="flex-start", width="100%"
+ ),
+ )
+ canonize_btn = widgets.Button(
+ description="Canonize peaks for material",
+ button_style="info",
+ tooltip="Save current spectrum's peak centers as canonical for this material",
+ layout=widgets.Layout(width="260px"),
+ )
+ canonize_confirm_btn = widgets.Button(
+ description="Confirm canonization",
+ button_style="warning",
+ tooltip="Confirm saving the current peak centers as canonical for this material",
+ layout=widgets.Layout(width="200px"),
+ )
+ canonize_cancel_btn = widgets.Button(
+ description="Cancel canonization",
+ button_style="",
+ tooltip="Cancel and return without changing materials.json",
+ layout=widgets.Layout(width="190px"),
+ )
+ try:
+ canonize_confirm_btn.layout.display = "none"
+ canonize_cancel_btn.layout.display = "none"
+ except Exception:
+ pass
+ load_canon_btn = widgets.Button(
+ description="Load canon peaks",
+ button_style="info",
+ tooltip="Load canonical peak centers from materials.json for this material",
+ layout=widgets.Layout(width="190px"),
+ )
+ edit_actions_row = widgets.HBox(
+ [
+ add_peaks_btn,
+ delete_peaks_btn,
+ canonize_btn,
+ canonize_confirm_btn,
+ canonize_cancel_btn,
+ load_canon_btn,
+ ],
+ layout=widgets.Layout(
+ flex_flow="row wrap", align_items="center", justify_content="flex-start", width="100%"
+ ),
+ )
+ optimize_actions_row = widgets.HBox(
+ [iter_btn, reset_all_btn],
+ layout=widgets.Layout(
+ flex_flow="row wrap", align_items="center", justify_content="flex-start", width="100%"
+ ),
+ )
+ # Alias: existing code toggles reset_all_row; make it refer to the optimize row
+ reset_all_row = optimize_actions_row
+ # Additional rows that are shown contextually
+ add_peaks_actions_row = widgets.HBox(
+ [accept_new_peaks_btn, redo_new_peaks_btn, cancel_new_peaks_btn],
+ layout=widgets.Layout(
+ flex_flow="row wrap", align_items="center", justify_content="flex-start", width="100%"
+ ),
+ )
+ delete_actions_row = widgets.HBox(
+ [accept_deletions_btn, redo_deletions_btn, cancel_deletions_btn],
+ layout=widgets.Layout(
+ flex_flow="row wrap", align_items="center", justify_content="flex-start", width="100%"
+ ),
+ )
+ # Hide contextual rows initially
+ try:
+ add_peaks_actions_row.layout.display = "none"
+ delete_actions_row.layout.display = "none"
+ except Exception:
+ pass
+ status_row = widgets.HBox([status_html])
+ cancel_row = widgets.HBox([cancel_fit_btn])
+ try:
+ cancel_row.layout.display = "none"
+ except Exception:
+ pass
+ # Colab fallback slider + typed input + Add button for peak addition
+ add_peaks_slider = widgets.FloatSlider(
+ value=float((xmin + xmax) / 2.0),
+ min=float(xmin),
+ max=float(xmax),
+ step=(float(xmax) - float(xmin)) / 1000.0 or 1.0,
+ description="Select (cm⁻¹)",
+ continuous_update=False,
+ readout_format=".1f",
+ layout=widgets.Layout(width="70%"),
+ )
+ add_peaks_text = widgets.FloatText(
+ value=float((xmin + xmax) / 2.0),
+ description="Type (cm⁻¹)",
+ layout=widgets.Layout(width="160px"),
+ )
+ add_peaks_add_btn = widgets.Button(
+ description="Add", button_style="info", layout=widgets.Layout(width="80px")
+ )
+
+ # Keep text and slider in sync (slider drives text)
+ def _sync_text_from_slider(change):
+ if change.get("name") != "value":
+ return
+ try:
+ add_peaks_text.value = float(change.get("new"))
+ except Exception:
+ pass
+
+ add_peaks_slider.observe(_sync_text_from_slider, names="value")
+ # Colab delete-by-number: enter peak index (1-based) to delete
+ delete_peak_num_text = widgets.IntText(
+ value=1,
+ description="Peak #",
+ layout=widgets.Layout(width="140px"),
+ )
+ delete_peak_num_btn = widgets.Button(
+ description="Delete",
+ button_style="danger",
+ layout=widgets.Layout(width="100px"),
+ )
+ colab_delete_row = widgets.HBox([delete_peak_num_text, delete_peak_num_btn])
+ colab_delete_help = widgets.HTML(
+ "Colab: Enter the peak number (as shown in the list) to delete."
+ )
+ colab_add_row = widgets.HBox([add_peaks_slider, add_peaks_text, add_peaks_add_btn])
+ colab_add_help = widgets.HTML(
+ "Colab: Use the slider or type a wavenumber, then click Add. Peaks snap to nearest data point; Accept to commit."
+ )
+ # Hide row if not in Colab or not in add-peaks mode
+ if not _IN_COLAB:
+ colab_add_row.layout.display = "none"
+ colab_add_help.layout.display = "none"
+ colab_delete_row.layout.display = "none"
+ colab_delete_help.layout.display = "none"
+ # Place plot + mark row in a bordered container; keep mark below the plot
+ plot_and_mark_deconv = widgets.VBox(
+ [fig, mark_row],
+ layout=widgets.Layout(border="1px solid #ccc", padding="8px", margin="6px 0"),
+ )
+ ui = widgets.VBox(
+ [
+ # 1) Material and Conditions
+ controls_row_filters,
+ # 2) Spectrum dropdown + Include bad checkbox
+ controls_row_spectrum,
+ # 3) Plot container (with mark buttons below plot)
+ plot_and_mark_deconv,
+ # Status (reduced chi-square and operation updates) directly under plot
+ status_row,
+ # Cancel button row (visible only during long-running fits)
+ cancel_row,
+ # 4) Primary actions rows (before Fit X-ranges)
+ primary_actions_row,
+ edit_actions_row,
+ optimize_actions_row,
+ # Contextual action rows
+ add_peaks_actions_row,
+ delete_actions_row,
+ # Colab add controls (only shown in Colab when adding)
+ colab_add_row,
+ colab_add_help,
+ # Colab delete controls (only shown in Colab when deleting)
+ colab_delete_row,
+ colab_delete_help,
+ # 6) X range selector bar
+ fit_range_row,
+ # 7) List of peaks and per-peak controls
+ peak_controls_section,
+ ]
+ )
+
+ # --- Canonize/Load canonical peaks handlers ---
+ def _materials_json_path():
+ try:
+ base_dir_js = os.path.dirname(__file__)
+ except Exception:
+ base_dir_js = os.getcwd()
+ return os.path.join(base_dir_js, "materials.json")
+
+ def _lookup_material_code(top: dict, mat_name: str):
+ try:
+ m = str(mat_name)
+ except Exception:
+ m = mat_name
+ if not isinstance(top, dict):
+ return None
+ for k, payload in top.items():
+ try:
+ if not isinstance(payload, dict):
+ continue
+ alias = str(payload.get("alias", ""))
+ namev = str(payload.get("name", ""))
+ if alias == m or namev == m:
+ return k
+ except Exception:
+ continue
+ return None
+
+ def _current_material_name():
+ try:
+ mval = material_dd.value
+ if mval and str(mval).lower() != "any":
+ return str(mval)
+ except Exception:
+ pass
+ # fallback to spectrum row value
+ try:
+ idx = spectrum_sel.value
+ return str(FTIR_DataFrame.loc[idx].get("Material", ""))
+ except Exception:
+ return ""
+
+ def _canonize_peaks_for_material(_b=None):
+ # Get current peaks centers
+ try:
+ idx = spectrum_sel.value
+ except Exception:
+ idx = None
+ if idx is None:
+ _append_status("No spectrum selected to canonize peaks from.")
+ return
+ try:
+ xs, ys = _get_peaks(idx)
+ except Exception:
+ xs, ys = ([], [])
+ centers = [float(x) for x in (xs or [])]
+ if not centers:
+ _append_status("No peaks available to canonize.")
+ return
+ # Sort by wavenumber to maintain order
+ centers = sorted(centers)
+ mat_name = _current_material_name()
+ if not mat_name:
+ _append_status("Material not determined; cannot update materials.json.")
+ return
+ # Load JSON
+ try:
+ mpath = _materials_json_path()
+ with open(mpath, "r", encoding="utf-8") as jf:
+ content = json.load(jf)
+ except Exception as e:
+ _append_status(f"Failed to read materials.json: {e}")
+ return
+ if not isinstance(content, list) or not content or not isinstance(content[0], dict):
+ _append_status("materials.json structure unexpected; aborting.")
+ return
+ top = content[0]
+ code_key = _lookup_material_code(top, mat_name)
+ if code_key is None:
+ _append_status(f"Material '{mat_name}' not found in materials.json.")
+ return
+ mat_payload = dict(top.get(code_key, {}))
+ peaks_payload = dict(mat_payload.get("peaks", {})) if isinstance(mat_payload.get("peaks"), dict) else {}
+ # Build new mapping while preserving existing per-peak σ/α when present
+ new_len = len(centers)
+ new_map = {}
+ for i, c in enumerate(centers, start=1):
+ key = str(i)
+ prev = peaks_payload.get(key, {}) if isinstance(peaks_payload, dict) else {}
+ try:
+ sigma_prev = float(prev.get("σ", 0.0))
+ except Exception:
+ sigma_prev = 0.0
+ try:
+ alpha_prev = float(prev.get("α", 0.0))
+ except Exception:
+ alpha_prev = 0.0
+ new_map[key] = {
+ "name": str(prev.get("name", "")),
+ "center_wavenumber": float(c),
+ "σ": sigma_prev,
+ "α": alpha_prev,
+ }
+ # Replace peaks, effectively adding/removing to match current set
+ mat_payload["peaks"] = new_map
+ top[code_key] = mat_payload
+ try:
+ with open(mpath, "w", encoding="utf-8") as jf:
+ json.dump(content, jf, indent=4, ensure_ascii=False)
+ _append_status(f"Canonized {new_len} peak(s) for material '{mat_name}'.")
+ except Exception as e:
+ _append_status(f"Failed to write materials.json: {e}")
+
+ # Restore canonize UI after a canonization attempt
+ try:
+ _show(canonize_btn)
+ _hide(canonize_confirm_btn)
+ _hide(canonize_cancel_btn)
+ except Exception:
+ pass
+
+ def _load_canon_peaks(_b=None):
+ mat_name = _current_material_name()
+ if not mat_name:
+ _append_status("Material not determined; cannot load canonical peaks.")
+ return
+ try:
+ mpath = _materials_json_path()
+ with open(mpath, "r", encoding="utf-8") as jf:
+ content = json.load(jf)
+ except Exception as e:
+ _append_status(f"Failed to read materials.json: {e}")
+ return
+ if not isinstance(content, list) or not content or not isinstance(content[0], dict):
+ _append_status("materials.json structure unexpected; aborting.")
+ return
+ top = content[0]
+ code_key = _lookup_material_code(top, mat_name)
+ if code_key is None:
+ _append_status(f"Material '{mat_name}' not found in materials.json.")
+ return
+ peaks_dict = {}
+ try:
+ peaks_dict = top.get(code_key, {}).get("peaks", {}) or {}
+ except Exception:
+ peaks_dict = {}
+ if not isinstance(peaks_dict, dict) or not peaks_dict:
+ _append_status(f"No canonical peaks stored for '{mat_name}'.")
+ return
+ # Build centers list ordered by numeric key
+ try:
+ ordered_items = sorted(((int(k), v) for k, v in peaks_dict.items()), key=lambda t: t[0])
+ centers = [float(v.get("center_wavenumber", 0.0)) for _k, v in ordered_items]
+ except Exception:
+ centers = []
+ if not centers:
+ _append_status(f"No valid canonical peak centers for '{mat_name}'.")
+ return
+ # Apply to current spectrum: set Peak Wavenumbers and infer amplitudes from data
+ try:
+ idx = spectrum_sel.value
+ x_arr, y_arr = _get_xy(idx)
+ except Exception:
+ idx, x_arr, y_arr = None, None, None
+ if idx is None or x_arr is None or y_arr is None or getattr(x_arr, "size", 0) == 0:
+ _append_status("Cannot apply canonical peaks: current spectrum data unavailable.")
+ return
+ amps = []
+ for c in centers:
+ try:
+ i = int(np.argmin(np.abs(x_arr - float(c))))
+ amps.append(float(y_arr[i]))
+ except Exception:
+ amps.append(0.0)
+ # Persist into DataFrame
+ try:
+ FTIR_DataFrame.at[idx, "Peak Wavenumbers"] = list(centers)
+ FTIR_DataFrame.at[idx, "Peak Absorbances"] = list(amps)
+ # Optional column to mark usage
+ if "Using Canon Peaks" not in FTIR_DataFrame.columns:
+ FTIR_DataFrame["Using Canon Peaks"] = None
+ FTIR_DataFrame.at[idx, "Using Canon Peaks"] = "True"
+ except Exception:
+ pass
+ # Clear caches to reflect new list
+ try:
+ if isinstance(peak_box_cache, dict):
+ peak_box_cache.clear()
+ except Exception:
+ pass
+ try:
+ included_index_map.clear()
+ except Exception:
+ pass
+ try:
+ last_result_by_idx.pop(idx, None)
+ except Exception:
+ pass
+ try:
+ last_redchi_by_idx.pop(idx, None)
+ except Exception:
+ pass
+ try:
+ _refresh_peak_control_widgets(idx)
+ except Exception:
+ pass
+ _append_status(f"Loaded {len(centers)} canonical peak(s) for '{mat_name}'.")
+
+ def _begin_canonize_confirmation(_b=None):
+ # Replace the canonize button with Confirm/Cancel
+ try:
+ _hide(canonize_btn)
+ _show(canonize_confirm_btn)
+ _show(canonize_cancel_btn)
+ except Exception:
+ pass
+
+ def _cancel_canonize_confirmation(_b=None):
+ try:
+ _show(canonize_btn)
+ _hide(canonize_confirm_btn)
+ _hide(canonize_cancel_btn)
+ except Exception:
+ pass
+
+ canonize_btn.on_click(_begin_canonize_confirmation)
+ canonize_confirm_btn.on_click(_canonize_peaks_for_material)
+ canonize_cancel_btn.on_click(_cancel_canonize_confirmation)
+ load_canon_btn.on_click(_load_canon_peaks)
+
+ # --- Add-peaks workflow callbacks ---
+ def _enter_add_mode(b=None):
+ if _recent_click("enter_add_mode"):
+ return
+ nonlocal adding_mode
+ adding_mode = True
+ new_peak_xs.clear()
+ _clear_add_peak_shapes()
+ _hide(add_peaks_btn)
+ # Ensure plot click is wired for add-mode selections (desktop)
+ try:
+ if not _IN_COLAB:
+ fig.data[0].on_click(_on_data_click)
+ except Exception:
+ pass
+ # Hide Delete peaks if present
+ try:
+ delete_peaks_btn.layout.display = "none"
+ except Exception:
+ pass
+ # Hide canon buttons during add-peaks mode
+ try:
+ _hide(canonize_btn)
+ except Exception:
+ pass
+ try:
+ _hide(load_canon_btn)
+ except Exception:
+ pass
+ # Hide non-relevant controls in Peak Addition mode
+ _hide(fit_btn)
+ _hide(reset_all_row)
+ _hide(fit_range_row)
+ # Show add-peaks contextual row
+ try:
+ add_peaks_actions_row.layout.display = ""
+ except Exception:
+ pass
+ _show(accept_new_peaks_btn)
+ _show(redo_new_peaks_btn)
+ _show(cancel_new_peaks_btn)
+ # Hide parameter modifiers during add-peaks mode
+ _hide(iter_btn)
+ try:
+ cancel_fit_btn.disabled = True
+ except Exception:
+ pass
+ _hide_cancel_button()
+ _hide(save_btn)
+ _hide(close_btn)
+ _hide(peak_controls_box)
+ # Disable selection widgets to avoid changing spectrum/filters mid-selection
+ try:
+ spectrum_sel.disabled = True
+ material_dd.disabled = True
+ conditions_dd.disabled = True
+ except Exception:
+ pass
+ if _IN_COLAB:
+ # Show slider row/help and set bounds from current spectrum
+ try:
+ x_arr, _y_arr = _get_xy(spectrum_sel.value)
+ if x_arr is not None and x_arr.size > 0:
+ x_min = float(np.nanmin(x_arr))
+ x_max = float(np.nanmax(x_arr))
+ add_peaks_slider.min = x_min
+ add_peaks_slider.max = x_max
+ add_peaks_slider.step = (x_max - x_min) / 1000.0 or 1.0
+ mid = float((x_min + x_max) / 2.0)
+ add_peaks_slider.value = mid
+ try:
+ add_peaks_text.value = mid
+ except Exception:
+ pass
+ except Exception:
+ pass
+ try:
+ colab_add_row.layout.display = ""
+ colab_add_help.layout.display = ""
+ except Exception:
+ pass
+ _log_once(
+ "Add-peaks mode (Colab): use the slider then click Add; Accept/Redo/Cancel when done."
+ )
+ else:
+ _log_once(
+ "Add-peaks mode: click x-locations on the plot; then Accept/Redo/Cancel."
+ )
+
+ # --- Delete-peaks workflow ---
+ deleting_mode = False
+ delete_markers_drawn = False
+
+ def _clear_delete_peak_shapes():
+ try:
+ shapes = list(getattr(fig.layout, "shapes", ()))
+ shapes = [s for s in shapes if getattr(s, "name", None) != "delete_peak_marker"]
+ fig.layout.shapes = tuple(shapes)
+ except Exception:
+ # dict fallback
+ try:
+ shapes = list(getattr(fig.layout, "shapes", ()))
+ new_shapes = []
+ for s in shapes:
+ try:
+ if s.get("name") != "delete_peak_marker":
+ new_shapes.append(s)
+ except Exception:
+ new_shapes.append(s)
+ fig.layout.shapes = tuple(new_shapes)
+ except Exception:
+ pass
+
+ def _draw_current_peaks_for_delete(idx):
+ nonlocal delete_markers_drawn
+ _clear_delete_peak_shapes()
+ xs, _ys = _get_visible_peaks(idx)
+ x_arr, y_arr = _get_xy(idx)
+ if not xs or x_arr is None or y_arr is None or x_arr.size == 0:
+ delete_markers_drawn = False
+ return
+ y_min = float(np.nanmin(y_arr))
+ y_max = float(np.nanmax(y_arr))
+ for cx in xs:
+ try:
+ fig.add_shape(
+ dict(
+ type="line",
+ x0=float(cx),
+ x1=float(cx),
+ y0=y_min,
+ y1=y_max,
+ line=dict(color="#d62728", dash="dash", width=1.5),
+ name="delete_peak_marker",
+ )
+ )
+ except Exception:
+ pass
+ delete_markers_drawn = True
+
+ # Staging for deletions and snapshot
+ staged_delete_indices = []
+ _delete_snapshot = {}
+
+ def _enter_delete_mode(b=None):
+ if _recent_click("enter_delete_mode"):
+ return
+ nonlocal deleting_mode
+ deleting_mode = True
+ staged_delete_indices.clear()
+ # Bind delete-mode click handler (desktop)
+ try:
+ if not _IN_COLAB:
+ fig.data[0].on_click(_on_delete_click)
+ except Exception:
+ pass
+ # Hide the Delete Peaks button itself while in delete mode
+ try:
+ delete_peaks_btn.layout.display = "none"
+ except Exception:
+ pass
+ # Hide canon buttons during delete-peaks mode
+ try:
+ _hide(canonize_btn)
+ except Exception:
+ pass
+ try:
+ _hide(load_canon_btn)
+ except Exception:
+ pass
+ # Snapshot current state
+ try:
+ idx = spectrum_sel.value
+ _delete_snapshot = {}
+ except Exception:
+ _delete_snapshot = {}
+ _hide(add_peaks_btn)
+ try:
+ # Hide Fit and unrelated controls
+ _hide(fit_btn)
+ _hide(reset_all_row)
+ _hide(fit_range_row)
+ # Show Delete button hidden state is handled by creating it below
+ # Hide accept/redo/cancel for add-peaks
+ _hide(accept_new_peaks_btn)
+ _hide(redo_new_peaks_btn)
+ _hide(cancel_new_peaks_btn)
+ # Show delete-action row
+ try:
+ delete_actions_row.layout.display = ""
+ except Exception:
+ pass
+ # Hide add-peaks action row if visible
+ try:
+ add_peaks_actions_row.layout.display = "none"
+ except Exception:
+ pass
+ _hide(iter_btn)
+ cancel_fit_btn.disabled = True
+ _hide_cancel_button()
+ _hide(save_btn)
+ _hide(close_btn)
+ _hide(peak_controls_box)
+ except Exception:
+ pass
+ try:
+ spectrum_sel.disabled = True
+ material_dd.disabled = True
+ conditions_dd.disabled = True
+ except Exception:
+ pass
+ idx = spectrum_sel.value
+ _draw_current_peaks_for_delete(idx)
+ if _IN_COLAB:
+ try:
+ colab_delete_row.layout.display = ""
+ colab_delete_help.layout.display = ""
+ except Exception:
+ pass
+ _log_once("Delete-peaks mode (Colab): enter peak number and click Delete.")
+ else:
+ _log_once("Delete-peaks mode: click existing peak markers to delete.")
+
+ def _exit_delete_mode():
+ nonlocal deleting_mode
+ deleting_mode = False
+ _clear_delete_peak_shapes()
+ # Remove delete-mode click handler
+ try:
+ if not _IN_COLAB:
+ fig.data[0].on_click(None)
+ except Exception:
+ pass
+ _show(add_peaks_btn)
+ # Restore canon buttons when leaving delete mode
+ try:
+ _show(canonize_btn)
+ except Exception:
+ pass
+ try:
+ _show(load_canon_btn)
+ except Exception:
+ pass
+ # Restore the Delete Peaks button visibility when leaving delete mode
+ try:
+ delete_peaks_btn.layout.display = ""
+ except Exception:
+ pass
+ _show(fit_btn)
+ _show(reset_all_row)
+ _show(fit_range_row)
+ # Hide delete action row
+ try:
+ delete_actions_row.layout.display = "none"
+ except Exception:
+ pass
+ _show(iter_btn)
+ _update_cancel_fit_visibility()
+ _show(save_btn)
+ _show(close_btn)
+ _show(peak_controls_box)
+ if _IN_COLAB:
+ try:
+ colab_delete_row.layout.display = "none"
+ colab_delete_help.layout.display = "none"
+ except Exception:
+ pass
+ try:
+ spectrum_sel.disabled = False
+ material_dd.disabled = False
+ conditions_dd.disabled = False
+ except Exception:
+ pass
+
+ # Click handler to stage deletion of nearest visible peak when in delete mode
+ def _on_delete_click(trace, points, selector):
+ try:
+ nonlocal deleting_mode
+ if not deleting_mode:
+ return
+ if not points or not getattr(points, "xs", None):
+ return
+ x_clicked = float(points.xs[0])
+ except Exception:
+ return
+ idx = spectrum_sel.value
+ try:
+ vis_xs, _ = _get_visible_peaks(idx)
+ except Exception:
+ vis_xs = []
+ if not vis_xs:
+ _log_once("No peaks to delete.")
+ return
+ # Find nearest peak center
+ try:
+ nearest_i = int(np.argmin(np.abs(np.asarray(vis_xs, dtype=float) - x_clicked)))
+ except Exception:
+ nearest_i = None
+ if nearest_i is None:
+ return
+ # Stage deletion index
+ try:
+ if nearest_i not in staged_delete_indices:
+ staged_delete_indices.append(nearest_i)
+ _append_status(
+ f"Staged deletion: Peak {nearest_i + 1} at {vis_xs[nearest_i]:.3f} cm⁻¹."
+ )
+ else:
+ _append_status(
+ f"Peak {nearest_i + 1} already staged for deletion."
+ )
+ except Exception:
+ pass
+ _draw_current_peaks_for_delete(idx)
+
+ try:
+ if not _IN_COLAB:
+ fig.data[0].on_click(_on_delete_click)
+ except Exception:
+ pass
+
+ def _colab_delete_peak(_b=None):
+ idx = spectrum_sel.value
+ try:
+ peak_num = int(delete_peak_num_text.value)
+ except Exception:
+ return
+ if peak_num <= 0:
+ return
+ # Convert to 0-based index within visible peaks ordering
+ try:
+ vis_xs, _ = _get_visible_peaks(idx)
+ except Exception:
+ vis_xs = []
+ if not vis_xs:
+ return
+ target_i = peak_num - 1
+ if target_i < 0 or target_i >= len(vis_xs):
+ return
+ # Stage deletion by number
+ try:
+ if target_i not in staged_delete_indices:
+ staged_delete_indices.append(target_i)
+ _append_status(
+ f"Staged deletion: Peak {target_i + 1} at {vis_xs[target_i]:.3f} cm⁻¹."
+ )
+ except Exception:
+ pass
+ _draw_current_peaks_for_delete(idx)
+ # Wait for Accept before applying
+
+ delete_peak_num_btn.on_click(_colab_delete_peak)
+
+ # Bind Delete Peaks button
+ try:
+ delete_peaks_btn.on_click(_enter_delete_mode)
+ except Exception:
+ pass
+
+ # Wire Accept/Redo/Cancel deletions using placeholders indices 3,4,5
+ def _apply_staged_deletions():
+ try:
+ idx = spectrum_sel.value
+ xs, ys = _get_peaks(idx)
+ xs = list(xs or [])
+ ys = list(ys or [])
+ for del_i in sorted(staged_delete_indices, reverse=True):
+ try:
+ if 0 <= del_i < len(xs):
+ xs.pop(del_i)
+ except Exception:
+ pass
+ try:
+ if 0 <= del_i < len(ys):
+ ys.pop(del_i)
+ except Exception:
+ pass
+ FTIR_DataFrame.at[idx, "Peak Wavenumbers"] = xs
+ FTIR_DataFrame.at[idx, "Peak Absorbances"] = ys
+ except Exception:
+ pass
+
+ def _accept_deletions(_b=None):
+ if _recent_click("accept_deletions"):
+ return
+ try:
+ idx = spectrum_sel.value
+ vis_xs, _ = _get_visible_peaks(idx)
+ except Exception:
+ vis_xs = []
+ _apply_staged_deletions()
+ # Record in session changes for summary
+ try:
+ deleted_centers = [vis_xs[i] for i in staged_delete_indices if i < len(vis_xs)]
+ if 'deleted' not in _deconv_changes:
+ _deconv_changes['deleted'] = []
+ _deconv_changes['deleted'].append((idx, [float(c) for c in deleted_centers]))
+ except Exception:
+ pass
+ # Clear caches so main mode respects new peak list
+ try:
+ if isinstance(peak_box_cache, dict):
+ peak_box_cache.clear()
+ except Exception:
+ pass
+ try:
+ included_index_map.clear()
+ except Exception:
+ pass
+ try:
+ last_result_by_idx.pop(idx, None)
+ except Exception:
+ pass
+ try:
+ last_redchi_by_idx.pop(idx, None)
+ except Exception:
+ pass
+ # No staged peak additions are retained.
+ # Rebuild peak-center state mapping to align with new list length
+ try:
+ new_centers, _new_ys = _get_peaks(idx)
+ peak_center_state_by_idx[idx] = {
+ i: {'initial': float(c), 'user': float(c)} for i, c in enumerate(new_centers)
+ }
+ except Exception:
+ try:
+ new_centers, _new_ys = _get_peaks(idx)
+ peak_center_state_by_idx[idx] = {
+ i: {'initial': c, 'user': c} for i, c in enumerate(new_centers)
+ }
+ except Exception:
+ pass
+ _append_status("Deletions accepted and applied.")
+ try:
+ _refresh_peak_control_widgets(spectrum_sel.value)
+ except Exception:
+ pass
+ try:
+ _update_fit_range_indicator()
+ except Exception:
+ pass
+ staged_delete_indices.clear()
+ _exit_delete_mode()
+
+ def _redo_deletions(_b=None):
+ if _recent_click("redo_deletions"):
+ return
+ staged_delete_indices.clear()
+ try:
+ idx = spectrum_sel.value
+ xs_restore = list(_delete_snapshot.get('centers', []))
+ ys_restore = list(_delete_snapshot.get('amps', []))
+ FTIR_DataFrame.at[idx, "Peak Wavenumbers"] = xs_restore
+ FTIR_DataFrame.at[idx, "Peak Absorbances"] = ys_restore
+ except Exception:
+ pass
+ _draw_current_peaks_for_delete(spectrum_sel.value)
+ _append_status("Deletions cleared; restored original peaks.")
+
+ def _cancel_deletions(_b=None):
+ if _recent_click("cancel_deletions"):
+ return
+ try:
+ idx = spectrum_sel.value
+ xs_restore = list(_delete_snapshot.get('centers', []))
+ ys_restore = list(_delete_snapshot.get('amps', []))
+ FTIR_DataFrame.at[idx, "Peak Wavenumbers"] = xs_restore
+ FTIR_DataFrame.at[idx, "Peak Absorbances"] = ys_restore
+ except Exception:
+ pass
+ staged_delete_indices.clear()
+ _append_status("Deletions cancelled. No changes applied.")
+ _exit_delete_mode()
+
+ try:
+ accept_deletions_btn.on_click(_accept_deletions)
+ redo_deletions_btn.on_click(_redo_deletions)
+ cancel_deletions_btn.on_click(_cancel_deletions)
+ # Ensure hidden initially
+ delete_actions_row.layout.display = "none"
+ except Exception:
+ pass
+
+ def _accept_new_peaks(b=None):
+ if _recent_click("accept_new_peaks"):
+ return
+ nonlocal adding_mode
+ idx = spectrum_sel.value
+ x_arr, y_arr = _get_xy(idx)
+ if x_arr is None:
+ _log_once("Cannot accept: current spectrum has no normalized data.")
+ return
+ if len(new_peak_xs) == 0:
+ # Nothing selected; just exit mode
+ _cancel_new_peaks()
+ return
+ # Merge with existing peaks and sort; reject new peaks too close to existing
+ xs_existing, ys_existing = _get_peaks(idx)
+ xs_list = [float(v) for v in (xs_existing or [])]
+ ys_list = [float(v) for v in (ys_existing or [])]
+ old_sorted_centers = list(xs_list)
+ # Collect newly accepted (non-overlapping) peaks before integrating
+ valid_new_peaks = []
+
+ # Use per-peak windows from visible peaks for overlap checks
+ rejected_close = []
+ try:
+ peaks_x, _ = _get_visible_peaks(idx)
+ except Exception:
+ peaks_x = []
+ for x_new in new_peak_xs:
+ # Reject if new point falls inside any existing peak's per-peak window
+ overlapped = False
+ try:
+ for i, cx in enumerate(peaks_x or []):
+ try:
+ w_i = float(center_window_sliders[i].value)
+ except Exception:
+ w_i = float(PER_PEAK_DEFAULT_CENTER_WINDOW)
+ # Enforce minimum separation of 2× the per-peak Center ± window
+ if abs(float(cx) - float(x_new)) <= (2.0 * abs(w_i)):
+ overlapped = True
+ break
+ except Exception:
+ overlapped = False
+ if overlapped:
+ rejected_close.append(float(x_new))
+ continue
+ # find nearest y
+ try:
+ i = int(np.argmin(np.abs(x_arr - x_new)))
+ y_new = float(y_arr[i])
+ except Exception:
+ # If we cannot compute a nearest point, skip this new peak
+ continue
+ # Stash valid new peak (we'll integrate after the loop)
+ try:
+ valid_new_peaks.append((float(x_new), float(y_new)))
+ except Exception:
+ pass
+ # Integrate new peaks: build combined sorted list and update DataFrame.
+ # Note: we intentionally do NOT preserve parameter choices from the previous
+ # spectrum or from the pre-add state; after accepting, the spectrum derives
+ # from FTIR_DataFrame + defaults.
+ try:
+ for (c_new, a_new) in valid_new_peaks:
+ xs_list.append(float(c_new))
+ ys_list.append(float(a_new))
+ combined = sorted(zip(xs_list, ys_list), key=lambda t: float(t[0]))
+ new_centers = [float(c) for c, _a in combined] if combined else []
+ new_amplitudes = [float(_a) for _c, _a in combined] if combined else []
+ try:
+ peak_center_state_by_idx[idx] = {
+ i: {'initial': float(c), 'user': float(c)}
+ for i, c in enumerate(new_centers)
+ }
+ except Exception:
+ peak_center_state_by_idx[idx] = {
+ i: {'initial': c, 'user': c} for i, c in enumerate(new_centers)
+ }
+ # Persist the accepted peak set directly to the DataFrame so the spectrum
+ # always derives its state from FTIR_DataFrame (no cross-spectrum carry-over).
+ try:
+ # Use .at for scalar cell assignment; .loc with list-like values
+ # can be interpreted as iterable assignment and fail.
+ FTIR_DataFrame.at[idx, 'Peak Wavenumbers'] = list(new_centers)
+ FTIR_DataFrame.at[idx, 'Peak Absorbances'] = list(new_amplitudes)
+ except Exception:
+ pass
+ try:
+ if isinstance(peak_box_cache, dict):
+ peak_box_cache.clear()
+ except Exception:
+ pass
+ try:
+ included_index_map.clear()
+ except Exception:
+ pass
+ try:
+ last_result_by_idx.pop(idx, None)
+ except Exception:
+ pass
+ try:
+ last_redchi_by_idx.pop(idx, None)
+ except Exception:
+ pass
+ # No shared peaks template; rebuild reflects new list
+ except Exception as _e_add:
+ _log_once(f"Failed to integrate new peaks: {_e_add}")
+ _hide(accept_new_peaks_btn)
+ _hide(redo_new_peaks_btn)
+ _hide(cancel_new_peaks_btn)
+ # Restore previously hidden/disabled controls after exiting add-peaks mode
+ _show(fit_btn)
+ _show(reset_all_row)
+ _show(fit_range_row)
+ _show(iter_btn)
+ _update_cancel_fit_visibility()
+ _show(save_btn)
+ _show(close_btn)
+ _show(peak_controls_box)
+ # Restore canon buttons when leaving add-peaks mode
+ try:
+ _show(canonize_btn)
+ except Exception:
+ pass
+ try:
+ _show(load_canon_btn)
+ except Exception:
+ pass
+ # Exit add mode and restore Add peaks button
+ try:
+ adding_mode = False
+ _show(add_peaks_btn)
+ # Unbind add-mode click handler when add mode ends
+ try:
+ if not _IN_COLAB:
+ fig.data[0].on_click(None)
+ except Exception:
+ pass
+ # Ensure Delete Peaks button reappears after ending add mode
+ try:
+ delete_peaks_btn.layout.display = ""
+ except Exception:
+ pass
+ # Hide add-peaks actions row after exit
+ try:
+ add_peaks_actions_row.layout.display = "none"
+ except Exception:
+ pass
+ _clear_add_peak_shapes()
+ new_peak_xs.clear()
+ new_peak_windows.clear()
+ except Exception:
+ pass
+ # Rebuild UI to reflect newly added peaks
+ try:
+ _refresh_peak_control_widgets(idx)
+ except Exception:
+ pass
+ # Hide Colab slider row when exiting add-peaks mode via Accept
+ if _IN_COLAB:
+ try:
+ colab_add_row.layout.display = "none"
+ colab_add_help.layout.display = "none"
+ except Exception:
+ pass
+ try:
+ spectrum_sel.disabled = False
+ material_dd.disabled = False
+ conditions_dd.disabled = False
+ except Exception:
+ pass
+ # Status: show any rejections in red
+ if rejected_close:
+ joined = ", ".join(f"{v:.3f}" for v in rejected_close)
+ msg = (
+ "Rejected: {} are too close to existing peaks (must be ≥ 2× Center ± window away). "
+ "Tip: adjust per-peak Center ± sliders to make room."
+ ).format(joined)
+ try:
+ status_html.value = f"{msg}"
+ except Exception:
+ _log_once(msg)
+ else:
+ # Build informative message listing the newly staged peak centers.
+ try:
+ staged_centers = [p[0] for p in valid_new_peaks] if 'valid_new_peaks' in locals() else []
+ except Exception:
+ staged_centers = []
+ if staged_centers:
+ locs = ", ".join(f"{c:.3f}" for c in staged_centers)
+ _log_once(
+ f"New peaks accepted and staged at: {locs}. (Unsaved – run Fit then Save to commit.)"
+ )
+ else:
+ _log_once(
+ "New peaks staged (unsaved). Run Fit then click Save to commit."
+ )
+
+ def _redo_new_peaks(b=None):
+ if _recent_click("redo_new_peaks"):
+ return
+ new_peak_xs.clear()
+ _clear_add_peak_shapes()
+ if _IN_COLAB:
+ _log_once("Selection cleared. Use slider to select peaks again, then Add.")
+ else:
+ _log_once("Selection cleared. Click on the plot to select peaks again.")
+
+ def _cancel_new_peaks(b=None):
+ if _recent_click("cancel_new_peaks"):
+ return
+ nonlocal adding_mode
+ adding_mode = False
+ new_peak_xs.clear()
+ _clear_add_peak_shapes()
+ _show(add_peaks_btn)
+ # Unbind add-mode click handler when add mode is cancelled
+ try:
+ if not _IN_COLAB:
+ fig.data[0].on_click(None)
+ except Exception:
+ pass
+ # Ensure Delete Peaks button reappears when add mode is cancelled
+ try:
+ delete_peaks_btn.layout.display = ""
+ except Exception:
+ pass
+ _hide(accept_new_peaks_btn)
+ _hide(redo_new_peaks_btn)
+ _hide(cancel_new_peaks_btn)
+ try:
+ add_peaks_actions_row.layout.display = "none"
+ except Exception:
+ pass
+ # Restore controls hidden during Peak Addition mode
+ _show(fit_btn)
+ _show(reset_all_row)
+ _show(fit_range_row)
+ # Restore previously hidden/disabled controls after cancelling add-peaks mode
+ _show(iter_btn)
+ _update_cancel_fit_visibility()
+ _show(save_btn)
+ _show(close_btn)
+ _show(peak_controls_box)
+ # Restore canon buttons when leaving add-peaks mode
+ try:
+ _show(canonize_btn)
+ except Exception:
+ pass
+ try:
+ _show(load_canon_btn)
+ except Exception:
+ pass
+ if _IN_COLAB:
+ try:
+ colab_add_row.layout.display = "none"
+ colab_add_help.layout.display = "none"
+ except Exception:
+ pass
+ try:
+ spectrum_sel.disabled = False
+ material_dd.disabled = False
+ conditions_dd.disabled = False
+ except Exception:
+ pass
+ _log_once("Peak addition cancelled. No changes were made.")
+
+ add_peaks_btn.on_click(_enter_add_mode)
+
+ # Colab slider-driven addition
+ def _colab_add_peak(_b=None):
+ try:
+ # Prefer typed value when provided; fall back to slider
+ x_target = float(add_peaks_text.value)
+ except Exception:
+ try:
+ x_target = float(add_peaks_slider.value)
+ except Exception:
+ return
+ idx = spectrum_sel.value
+ x_arr, y_arr = _get_xy(idx)
+ if x_arr is None or y_arr is None or x_arr.size == 0:
+ _log_once("Cannot add peak: spectrum has no normalized data.")
+ return
+ # Snap to nearest existing x
+ try:
+ nearest_i = int(np.argmin(np.abs(x_arr - x_target)))
+ x_new = float(x_arr[nearest_i])
+ except Exception:
+ _log_once("Could not determine nearest x for selected location.")
+ return
+ # Reject if within any existing visible peak's per-peak Center ± window
+ try:
+ vis_xs, _vis_ys = _get_visible_peaks(idx)
+ except Exception:
+ vis_xs = []
+ try:
+ default_win = float(PER_PEAK_DEFAULT_CENTER_WINDOW)
+ except Exception:
+ default_win = 0.0
+ try:
+ for i, cx in enumerate(vis_xs or []):
+ try:
+ w_i = float(center_window_sliders[i].value)
+ except Exception:
+ w_i = default_win
+ # Enforce minimum separation of 2× the per-peak Center ± window
+ if abs(float(cx) - float(x_new)) <= (2.0 * abs(w_i)):
+ _log_once(
+ f"Rejected: {x_new:.3f} cm⁻¹ is too close to existing peak @ {cx:.3f}. "
+ f"Must be ≥ 2×(Center ± window) = {2.0*abs(w_i):.1f} cm⁻¹ away. "
+ f"Adjust selection or that peak’s Center ± window."
+ )
+ return
+ except Exception:
+ pass
+ # Check against session-selected peaks using 2× window rule
+ try:
+ candidate_w = float(PER_PEAK_DEFAULT_CENTER_WINDOW)
+ except Exception:
+ candidate_w = 0.0
+ for existing_x in new_peak_xs:
+ try:
+ existing_w = float(new_peak_windows.get(existing_x, candidate_w))
+ except Exception:
+ existing_w = candidate_w
+ required_sep = 2.0 * max(abs(existing_w), abs(candidate_w))
+ if abs(existing_x - x_new) <= required_sep:
+ _log_once(
+ f"Rejected: {x_new:.3f} cm⁻¹ is too close to selected peak {existing_x:.3f}. "
+ f"Must be ≥ {required_sep:.2f} cm⁻¹ away (2× window)."
+ )
+ return
+ # Compute session-effective window vs existing peaks and store
+ try:
+ xs_existing, _ys_existing = _get_peaks(idx)
+ except Exception:
+ xs_existing = []
+ try:
+ if xs_existing:
+ min_dist = min(abs(float(xe) - x_new) for xe in xs_existing)
+ else:
+ min_dist = float('inf')
+ except Exception:
+ min_dist = float('inf')
+ try:
+ eff_window = float(PER_PEAK_DEFAULT_CENTER_WINDOW)
+ if np.isfinite(min_dist):
+ eff_window = min(eff_window, max(0.0, float(min_dist) - float(SESSION_WINDOW_MARGIN)))
+ except Exception:
+ eff_window = float(PER_PEAK_DEFAULT_CENTER_WINDOW)
+ try:
+ new_peak_windows[x_new] = float(eff_window)
+ except Exception:
+ pass
+ # Accept
+ new_peak_xs.append(x_new)
+ try:
+ y_min = float(np.nanmin(y_arr))
+ y_max = float(np.nanmax(y_arr))
+ except Exception:
+ y_min, y_max = 0.0, 1.0
+ try:
+ fig.add_shape(
+ dict(
+ type="line",
+ x0=x_new,
+ x1=x_new,
+ y0=y_min,
+ y1=y_max,
+ line=dict(color="#ff7f0e", dash="dot", width=1.5),
+ name="add_peak_marker",
+ )
+ )
+ except Exception:
+ pass
+ _log_once(f"Selected new peak at x = {x_new:.3f} cm⁻¹. Add more or Accept.")
+
+ try:
+ if _IN_COLAB:
+ add_peaks_add_btn.on_click(_colab_add_peak)
+ except Exception:
+ pass
+ accept_new_peaks_btn.on_click(_accept_new_peaks)
+ redo_new_peaks_btn.on_click(_redo_new_peaks)
+ cancel_new_peaks_btn.on_click(_cancel_new_peaks)
+
+ # Prime the peak controls so the list renders immediately on first display
+ try:
+ if spectrum_sel.value is not None:
+ current_idx_deconv = spectrum_sel.value
+ _refresh_peak_control_widgets(current_idx_deconv)
+ _update_fit_range_indicator()
+ _fix_y_range(current_idx_deconv)
+ except Exception:
+ pass
+
+ # Only display the UI (which already contains the figure) and the log
+ display(ui, log_html)
+ # Seed options with current filters (defaults 'any') and trigger initial updates
+ _rebuild_spectrum_options()
+
+ return FTIR_DataFrame
+
+
+def fit_material(FTIR_DataFrame):
+
+ """
+ Fit deconvoluted spectra of selected material to a unified set of peaks.
+
+ Parameters:
+ ----------
+ FTIR_DataFrame : pd.DataFrame
+ DataFrame containing FTIR spectral data and prior analysis results.
+
+ Returns:
+ -------
+ pd.DataFrame
+ Updated DataFrame with fit-results stored.
+ """
+ if FTIR_DataFrame is None or not isinstance(FTIR_DataFrame, pd.DataFrame):
+ raise ValueError("Error: FTIR_DataFrame not defined. Load or Create DataFrame first.")
+ if FTIR_DataFrame is None or len(FTIR_DataFrame) == 0:
+ raise ValueError("FTIR_DataFrame must be loaded and non-empty.")
+
+ required_cols = [
+ "Material",
+ "Time",
+ "Deconvolution Results",
+ "Deconvolution X-Ranges",
+ "X-Axis",
+ "Normalized and Corrected Data",
+ "Material Fit Results",
+ ]
+ missing = [c for c in required_cols if c not in FTIR_DataFrame.columns]
+ if missing:
+ raise KeyError(
+ f"Missing required column(s): {missing}. Ensure your DataFrame is prepared with prior steps."
+ )
+
+ try:
+ FTIR_DataFrame["Material Fit Results"] = FTIR_DataFrame[
+ "Material Fit Results"
+ ].astype(object)
+ except Exception:
+ pass
+
+ # --- Fit across all spectra of selected material ---
+ # Important: this tool uses ONLY peaks from 'Deconvolution Results' and
+ # uses ONLY the union of 'Deconvolution X-Ranges' for fitting/optimization.
+ import json, ast, os, numpy as np
+
+ # Shared (per-session) canonical parameters sourced from materials.json or computed
+ shared_centers_list = None # list[float]
+ shared_sigma_list = None # list[float]
+ shared_alpha_list = None # list[float]
+ shared_peak_numbers_list = None # list[int|None] (source: Deconvolution Results)
+
+ # Active union of X-Ranges for the current selection (material + include_bad)
+ current_union_x_ranges = [] # list[tuple[float, float]]
+
+ # Row indices actually used in the most recent Fit/Optimize (i.e., had usable
+ # Deconvolution Results that were incorporated into the canonical peak set).
+ last_used_fit_row_indices = set()
+
+ # materials.json helpers
+ def _load_materials_json():
+ try:
+ base_dir_js = os.path.dirname(__file__)
+ path = os.path.join(base_dir_js, "materials.json")
+ with open(path, "r", encoding="utf-8") as jf:
+ content = json.load(jf)
+ return path, content
+ except Exception:
+ return None, None
+
+ def _lookup_material_code(top_dict, mat_name: str):
+ try:
+ for k, payload in top_dict.items():
+ if not isinstance(payload, dict):
+ continue
+ if (
+ str(payload.get("alias", "")).strip() == str(mat_name)
+ or str(payload.get("name", "")).strip() == str(mat_name)
+ ):
+ return k
+ except Exception:
+ pass
+ return None
+
+ def _canon_from_json(mat_name: str):
+ """Return (centers, sigmas, alphas) from materials.json for a material.
+ Falls back to empty lists when unavailable.
+ """
+ path, content = _load_materials_json()
+ if content is None or not isinstance(content, list) or not content:
+ return [], [], []
+ top = content[0] if isinstance(content[0], dict) else {}
+ code = _lookup_material_code(top, mat_name)
+ if code is None:
+ return [], [], []
+ payload = top.get(code, {})
+ try:
+ peaks = payload.get("peaks", {}) or {}
+ except Exception:
+ peaks = {}
+ centers, sigmas, alphas = [], [], []
+ try:
+ # Sort by numeric key order "1","2",...
+ for idx_key in sorted(peaks.keys(), key=lambda s: int(str(s)) if str(s).isdigit() else str(s)):
+ p = peaks.get(idx_key, {}) or {}
+ try:
+ centers.append(float(p.get("center_wavenumber", 0.0)))
+ except Exception:
+ centers.append(0.0)
+ try:
+ sigmas.append(float(p.get("σ", 0.0)))
+ except Exception:
+ sigmas.append(0.0)
+ try:
+ alphas.append(float(p.get("α", 0.0)))
+ except Exception:
+ alphas.append(0.0)
+ except Exception:
+ pass
+ return centers, sigmas, alphas
+
+ # Shared parameters are computed on-demand in _compute_for_selection / _optimize_centers_for_selection
+ # from the DataFrame's 'Deconvolution Results' (no dependency on materials.json for peak selection).
+
+ # -------------------------- Backend helpers --------------------------- #
+ def _parse_deconv(val):
+ """Parse a Deconvolution Results cell to a list[dict] or None."""
+ if val is None:
+ return None
+ if isinstance(val, str):
+ try:
+ v = ast.literal_eval(val)
+ except Exception:
+ return None
+ else:
+ v = val
+ if isinstance(v, list):
+ # Ensure items are dicts and sort by center if present
+ try:
+ items = [dict(d) for d in v if isinstance(d, dict)]
+ except Exception:
+ return None
+ try:
+ items = sorted(
+ items, key=lambda d: float(d.get("center", float("nan")))
+ )
+ except Exception:
+ # If centers not coercible, keep original order
+ pass
+ return items
+ return None
+
+ def _parse_x_ranges(val):
+ """Parse a Deconvolution X-Ranges cell to list[(lo, hi)] in ascending order."""
+ if val is None:
+ return []
+ v = val
+ if isinstance(v, str):
+ try:
+ v = ast.literal_eval(v)
+ except Exception:
+ return []
+ if not isinstance(v, (list, tuple)):
+ return []
+ out = []
+ for item in v:
+ if not isinstance(item, (list, tuple)) or len(item) < 2:
+ continue
+ try:
+ a = float(item[0])
+ b = float(item[1])
+ except Exception:
+ continue
+ if not (np.isfinite(a) and np.isfinite(b)):
+ continue
+ lo = min(a, b)
+ hi = max(a, b)
+ # ignore degenerate intervals
+ if hi <= lo:
+ continue
+ out.append((lo, hi))
+ out.sort(key=lambda t: (t[0], t[1]))
+ return out
+
+ def _union_ranges(ranges):
+ """Merge overlapping/adjacent (lo, hi) pairs."""
+ if not ranges:
+ return []
+ rs = sorted([(float(lo), float(hi)) for lo, hi in ranges if np.isfinite(lo) and np.isfinite(hi)], key=lambda t: (t[0], t[1]))
+ if not rs:
+ return []
+ merged = [list(rs[0])]
+ for lo, hi in rs[1:]:
+ cur = merged[-1]
+ # merge if overlapping or touching
+ if lo <= cur[1]:
+ cur[1] = max(cur[1], hi)
+ else:
+ merged.append([lo, hi])
+ return [(float(a), float(b)) for a, b in merged]
+
+ def _collect_union_x_ranges(df_series):
+ all_rs = []
+ try:
+ for _idx, _row in df_series.iterrows():
+ all_rs.extend(_parse_x_ranges(_row.get("Deconvolution X-Ranges")))
+ except Exception:
+ pass
+ return _union_ranges(all_rs)
+
+ def _slice_to_union_ranges(x_arr, y_arr, union_ranges):
+ if not union_ranges:
+ return x_arr, y_arr
+ try:
+ x_np = np.asarray(x_arr, dtype=float)
+ y_np = np.asarray(y_arr, dtype=float)
+ n = min(x_np.size, y_np.size)
+ if n <= 1:
+ return x_np[:0], y_np[:0]
+ x_np = x_np[:n]
+ y_np = y_np[:n]
+ except Exception:
+ return None, None
+ mask = np.zeros(x_np.shape, dtype=bool)
+ for lo, hi in union_ranges:
+ try:
+ mask |= (x_np >= lo) & (x_np <= hi)
+ except Exception:
+ pass
+ if not np.any(mask):
+ return x_np[:0], y_np[:0]
+ return x_np[mask], y_np[mask]
+
+ def _parse_xy(row):
+ """Return (x_arr, y_arr) as 1D float arrays or (None, None)."""
+ x = row.get("X-Axis")
+ y = row.get("Normalized and Corrected Data")
+ if isinstance(x, str):
+ try:
+ x = ast.literal_eval(x)
+ except Exception:
+ return None, None
+ if isinstance(y, str):
+ try:
+ y = ast.literal_eval(y)
+ except Exception:
+ return None, None
+ try:
+ x_arr = np.asarray(x, dtype=float)
+ y_arr = np.asarray(y, dtype=float)
+ if x_arr.ndim != 1 or y_arr.ndim != 1 or x_arr.size != y_arr.size:
+ return None, None
+ except Exception:
+ return None, None
+ return x_arr, y_arr
+
+ def _mode_peak_count(lists_of_peaks):
+ """Return the most common positive length among lists; tie -> max length."""
+ lengths = [len(p) for p in lists_of_peaks if isinstance(p, list) and len(p) > 0]
+ if not lengths:
+ return 0
+ vals, counts = np.unique(lengths, return_counts=True)
+ # Choose value with max count; if tie, the larger length wins
+ max_count = np.max(counts)
+ candidates = [v for v, c in zip(vals, counts) if c == max_count]
+ return int(max(candidates))
+
+ def _parse_peak_number(v):
+ """Coerce a peak_number field to int when possible."""
+ if v is None:
+ return None
+ try:
+ if isinstance(v, (int, np.integer)):
+ return int(v)
+ if isinstance(v, float) and np.isfinite(v):
+ return int(v)
+ except Exception:
+ pass
+ try:
+ s = str(v).strip()
+ if not s:
+ return None
+ # Accept "18", "Peak 18", "peak_18" etc
+ m = re.search(r"(\d+)", s)
+ if not m:
+ return None
+ return int(m.group(1))
+ except Exception:
+ return None
+
+ def _compute_shared_peak_numbers_from_aligned(aligned_by_idx, k):
+ """Return list length k of most-common peak_number per canonical peak."""
+ nums_out = []
+ for i in range(int(k)):
+ candidates = []
+ try:
+ for _idx, aligned in (aligned_by_idx or {}).items():
+ if not isinstance(aligned, list) or i >= len(aligned):
+ continue
+ p = aligned[i]
+ if not isinstance(p, dict):
+ continue
+ pn = _parse_peak_number(p.get("peak_number"))
+ if pn is not None:
+ candidates.append(int(pn))
+ except Exception:
+ candidates = []
+ if not candidates:
+ nums_out.append(None)
+ continue
+ try:
+ vals, counts = np.unique(np.asarray(candidates, dtype=int), return_counts=True)
+ # Most frequent; tie -> smallest (stable)
+ max_count = int(np.max(counts))
+ best_vals = [int(v) for v, c in zip(vals.tolist(), counts.tolist()) if int(c) == max_count]
+ nums_out.append(int(min(best_vals)) if best_vals else None)
+ except Exception:
+ try:
+ nums_out.append(int(candidates[0]))
+ except Exception:
+ nums_out.append(None)
+ return nums_out
+
+ def _peak_labels_from_numbers(peak_numbers, k):
+ """Return unique column labels (length k) like 'Peak 18'."""
+ labels = []
+ seen = {}
+ for i in range(int(k)):
+ pn = None
+ try:
+ if isinstance(peak_numbers, list) and i < len(peak_numbers):
+ pn = peak_numbers[i]
+ except Exception:
+ pn = None
+ base = f"Peak {int(pn)}" if pn is not None else f"Peak {i+1}"
+ n = seen.get(base, 0) + 1
+ seen[base] = n
+ labels.append(base if n == 1 else f"{base} ({n})")
+ return labels
+
+ def _is_unexposed(val):
+ try:
+ return str(val).strip().lower() == "unexposed"
+ except Exception:
+ return False
+
+ # Compute only for the currently selected Material
+ def _compute_for_selection(material, include_bad=False):
+ # Build the series subset for the selected material
+ try:
+ series_df = FTIR_DataFrame[FTIR_DataFrame["Material"].astype(str) == str(material)].copy()
+ except Exception:
+ series_df = FTIR_DataFrame.copy()
+ # Optionally exclude rows marked as bad quality
+ if not include_bad:
+ try:
+ series_df = series_df[_quality_good_mask(series_df)]
+ except Exception:
+ pass
+ if series_df.empty:
+ print("No spectra found for the selected material.")
+ return
+
+ # Compute the union of all saved X-Ranges for this selection
+ nonlocal current_union_x_ranges
+ try:
+ current_union_x_ranges = _collect_union_x_ranges(series_df)
+ except Exception:
+ current_union_x_ranges = []
+
+ # Collect deconvolution peak lists for this series
+ peak_lists = []
+ peak_lists_by_idx = {}
+ for idx, row in series_df.iterrows():
+ peaks = _parse_deconv(row.get("Deconvolution Results"))
+ if peaks is not None and len(peaks) > 0:
+ peak_lists.append(peaks)
+ peak_lists_by_idx[idx] = peaks
+
+ # Build canonical centers by clustering all peak centers across spectra
+ sigma_samples = []
+ all_centers = []
+ for peaks in peak_lists:
+ for p in peaks:
+ try:
+ sval = float(p.get("sigma", p.get("σ", np.nan)))
+ if np.isfinite(sval):
+ sigma_samples.append(sval)
+ except Exception:
+ pass
+ try:
+ cval = float(p.get("center", p.get("center_wavenumber", np.nan)))
+ if np.isfinite(cval):
+ all_centers.append(cval)
+ except Exception:
+ pass
+ try:
+ tol = float(np.nanmedian(sigma_samples)) if np.isfinite(np.nanmedian(sigma_samples)) else 8.0
+ except Exception:
+ tol = 8.0
+ try:
+ centers_sorted = sorted(set([float(c) for c in all_centers if np.isfinite(c)]))
+ except Exception:
+ centers_sorted = []
+ canonical_centers = []
+ for c in centers_sorted:
+ if not canonical_centers:
+ canonical_centers.append(c)
+ continue
+ if abs(c - canonical_centers[-1]) <= tol:
+ canonical_centers[-1] = (canonical_centers[-1] + c) / 2.0
+ else:
+ canonical_centers.append(c)
+ k = len(canonical_centers)
+ if k <= 0:
+ print("Could not establish canonical peaks for the series.")
+ return
+
+ # Align each spectrum to the canonical centers; add missing peaks with amplitude 0
+ aligned_by_idx = {}
+ for idx, peaks in peak_lists_by_idx.items():
+ aligned = [None] * k
+ used = set()
+ for i, ccan in enumerate(canonical_centers):
+ best_j = None
+ best_d = float("inf")
+ for j, p in enumerate(peaks):
+ if j in used:
+ continue
+ try:
+ cval = float(p.get("center", p.get("center_wavenumber", np.nan)))
+ except Exception:
+ cval = float("nan")
+ if not np.isfinite(cval):
+ continue
+ d = abs(cval - ccan)
+ if d < best_d:
+ best_d = d
+ best_j = j
+ if best_j is not None and best_d <= tol:
+ aligned[i] = dict(peaks[best_j])
+ used.add(best_j)
+ else:
+ aligned[i] = {
+ "amplitude": 0.0,
+ "A": 0.0,
+ "center": float(ccan),
+ "alpha": 0.5,
+ "fraction": 0.5,
+ "α": 0.5,
+ "sigma": float(np.nanmedian(sigma_samples)) if np.isfinite(np.nanmedian(sigma_samples)) else 10.0,
+ "σ": float(np.nanmedian(sigma_samples)) if np.isfinite(np.nanmedian(sigma_samples)) else 10.0,
+ }
+ aligned_by_idx[idx] = aligned
+
+ # Track which rows were actually used (had usable deconvolution results)
+ nonlocal last_used_fit_row_indices
+ try:
+ last_used_fit_row_indices = set(aligned_by_idx.keys())
+ except Exception:
+ last_used_fit_row_indices = set()
+
+ # Compute averages over aligned peaks
+ centers, sigmas, alphas = [], [], []
+ for idx, aligned in aligned_by_idx.items():
+ try:
+ centers.append([float(p.get("center", p.get("center_wavenumber", np.nan))) for p in aligned])
+ sigmas.append([float(p.get("sigma", p.get("σ", np.nan))) for p in aligned])
+ alphas.append([float(p.get("alpha", p.get("fraction", p.get("α", np.nan)))) for p in aligned])
+ except Exception:
+ continue
+ centers = np.asarray(centers, dtype=float)
+ sigmas = np.asarray(sigmas, dtype=float)
+ alphas = np.asarray(alphas, dtype=float)
+ with np.errstate(all="ignore"):
+ avg_center = np.nanmean(centers, axis=0)
+ avg_sigma = np.nanmean(sigmas, axis=0)
+ avg_alpha = np.nanmean(alphas, axis=0)
+ for i in range(k):
+ if not np.isfinite(avg_center[i]):
+ vals = centers[:, i]
+ avg_center[i] = np.nanmedian(vals) if np.isfinite(np.nanmedian(vals)) else 0.0
+ if not np.isfinite(avg_sigma[i]):
+ vals = sigmas[:, i]
+ avg_sigma[i] = np.nanmedian(vals) if np.isfinite(np.nanmedian(vals)) else 10.0
+ if not np.isfinite(avg_alpha[i]):
+ vals = alphas[:, i]
+ avg_alpha[i] = np.nanmedian(vals) if np.isfinite(np.nanmedian(vals)) else 0.5
+
+ # Update shared parameters for plotting and downstream fitting
+ nonlocal shared_centers_list, shared_sigma_list, shared_alpha_list, shared_peak_numbers_list
+ try:
+ shared_centers_list = [float(v) for v in avg_center.tolist()]
+ except Exception:
+ shared_centers_list = [float(c) for c in canonical_centers]
+ try:
+ shared_sigma_list = [float(v) if np.isfinite(v) else 10.0 for v in avg_sigma.tolist()]
+ except Exception:
+ shared_sigma_list = [10.0] * k
+ try:
+ shared_alpha_list = [float(np.clip(v, 0.0, 1.0)) if np.isfinite(v) else 0.5 for v in avg_alpha.tolist()]
+ except Exception:
+ shared_alpha_list = [0.5] * k
+ try:
+ shared_peak_numbers_list = _compute_shared_peak_numbers_from_aligned(aligned_by_idx, k)
+ except Exception:
+ shared_peak_numbers_list = [None] * k
+
+ # Using averaged parameters, refit amplitudes per spectrum with lmfit.
+ assigned = 0
+ refit_logs = [] # collect per-spectrum status messages
+ for idx, aligned in aligned_by_idx.items():
+ try:
+ x_arr, y_arr = _parse_xy(series_df.loc[idx])
+ except Exception:
+ x_arr, y_arr = None, None
+ if (
+ x_arr is None
+ or y_arr is None
+ or np.asarray(x_arr).size == 0
+ or np.asarray(y_arr).size == 0
+ ):
+ # Fall back to preserving amplitudes when data unavailable
+ try:
+ refit_logs.append(f"Row {idx}: no data available; preserved amplitudes.")
+ except Exception:
+ pass
+ # Persist amplitude-only results
+ out_amps = []
+ for i in range(k):
+ try:
+ out_amps.append(float(aligned[i].get("amplitude", 0.0)))
+ except Exception:
+ out_amps.append(0.0)
+ try:
+ FTIR_DataFrame.at[idx, "Material Fit Results"] = out_amps
+ assigned += 1
+ except Exception:
+ pass
+ continue
+
+ # Build composite model with fixed center/sigma/fraction and variable amplitudes
+ comp_model = None
+ params = None
+ for i in range(k):
+ m = PseudoVoigtModel(prefix=f"p{i}_")
+ p = m.make_params()
+ # Use canonical centers and aggregated sigma/alpha
+ p[f"p{i}_center"].set(value=float(shared_centers_list[i]), vary=False)
+ p[f"p{i}_sigma"].set(value=float(shared_sigma_list[i]), min=1e-3, max=1e4, vary=False)
+ p[f"p{i}_fraction"].set(value=float(shared_alpha_list[i]), min=0.0, max=1.0, vary=False)
+ # Seed amplitude from aligned peak or a heuristic
+ try:
+ amp0 = float(aligned[i].get("amplitude", aligned[i].get("A", 1.0)))
+ if not np.isfinite(amp0):
+ raise ValueError()
+ except Exception:
+ # heuristic: local y at center times sigma scale
+ try:
+ ci = float(avg_center[i])
+ nearest = int(np.argmin(np.abs(np.asarray(x_arr, dtype=float) - ci)))
+ amp0 = max(0.0, float(np.asarray(y_arr, dtype=float)[nearest]) * max(1.0, float(avg_sigma[i])))
+ except Exception:
+ amp0 = 1.0
+ p[f"p{i}_amplitude"].set(value=max(0.0, amp0), min=0.0)
+ if comp_model is None:
+ comp_model = m
+ params = p
+ else:
+ comp_model = comp_model + m
+ params.update(p)
+
+ # Sanitize input arrays: drop non-finite points and ensure matching lengths
+ try:
+ x_np = np.asarray(x_arr, dtype=float)
+ y_np = np.asarray(y_arr, dtype=float)
+ n = min(x_np.size, y_np.size)
+ if n <= 1:
+ raise ValueError("Insufficient data points for fitting")
+ x_np = x_np[:n]
+ y_np = y_np[:n]
+ mask = np.isfinite(x_np) & np.isfinite(y_np)
+ if not np.any(mask):
+ raise ValueError("No finite data points for fitting")
+ x_np = x_np[mask]
+ y_np = y_np[mask]
+
+ # Restrict fit to the UNION of the saved Deconvolution X-Ranges
+ try:
+ x_np, y_np = _slice_to_union_ranges(x_np, y_np, current_union_x_ranges)
+ except Exception:
+ pass
+ if x_np is None or y_np is None or x_np.size <= 1 or y_np.size <= 1:
+ raise ValueError("No data points in selected Deconvolution X-Ranges")
+ # Log heavy sanitization
+ try:
+ removed = int(n - x_np.size)
+ except Exception:
+ pass
+ # Guard: centers outside x-range -> fix amplitude to 0 and do not vary
+ try:
+ x_min_loc = float(np.nanmin(x_np))
+ x_max_loc = float(np.nanmax(x_np))
+ except Exception:
+ x_min_loc, x_max_loc = None, None
+ if x_min_loc is not None and x_max_loc is not None and np.isfinite(x_min_loc) and np.isfinite(x_max_loc):
+ for i in range(k):
+ try:
+ ci = float(avg_center[i])
+ if not (x_min_loc <= ci <= x_max_loc):
+ # freeze amplitude to 0 for out-of-range peak
+ params[f"p{i}_amplitude"].set(value=0.0, min=0.0, vary=False)
+ refit_logs.append(
+ f"Row {idx}: center {ci:.6g} outside x-range [{x_min_loc:.6g}, {x_max_loc:.6g}] for Peak {i+1}; amplitude fixed to 0."
+ )
+ except Exception:
+ pass
+ # Optional scale guard: clip extreme magnitudes to reduce numeric issues
+ y_range = float(np.nanmax(y_np) - np.nanmin(y_np)) if y_np.size else 0.0
+ if np.isfinite(y_range) and y_range > 0:
+ y_np = np.clip(y_np, np.nanmin(y_np) - 10*y_range, np.nanmax(y_np) + 10*y_range)
+ res = comp_model.fit(y_np, params, x=x_np)
+ fit_list = []
+ for i in range(k):
+ try:
+ amp = float(res.params.get(f"p{i}_amplitude").value)
+ if not np.isfinite(amp):
+ amp = 0.0
+ except Exception:
+ amp = 0.0
+ fit_list.append(amp)
+ FTIR_DataFrame.at[idx, "Material Fit Results"] = fit_list
+ assigned += 1
+ except Exception as _fit_err:
+ # If fit fails, preserve amplitudes
+ try:
+ refit_logs.append(f"Row {idx}: fit failed ({_fit_err}); preserved amplitudes.")
+ except Exception:
+ pass
+ out_amps = []
+ for i in range(k):
+ try:
+ out_amps.append(float(aligned[i].get("amplitude", aligned[i].get("A", 0.0))))
+ except Exception:
+ out_amps.append(0.0)
+ try:
+ FTIR_DataFrame.at[idx, "Material Fit Results"] = out_amps
+ assigned += 1
+ except Exception:
+ pass
+
+ print(f"Amplitudes refit for Material={material} using canon centers. Updated {assigned} spectra.")
+ # Surface logs in the UI if available
+ try:
+ if refit_logs:
+ log_html = "
".join([widgets.HTML.escape(str(m)) if hasattr(widgets.HTML, 'escape') else str(m) for m in refit_logs])
+ optimize_status_html.value = (
+ "Refit Status
"
+ + f"{log_html}
"
+ )
+ except Exception:
+ pass
+
+ def _optimize_centers_for_selection(material, include_bad=False):
+ """Iteratively optimize shared centers and per-spectrum amplitudes to reduce SSE.
+
+ Approach:
+ - Coordinate descent on shared centers. For each peak, try +/- step shifts.
+ - For every center trial, re-fit amplitudes per spectrum with centers/σ/α fixed
+ against the 'Normalized and Corrected Data' to get the best amplitudes.
+ - Accept moves that lower the total SSE; shrink step when no progress; stop
+ after a few passes or when below tolerance.
+
+ Returns a status message and the optimized centers list (or None on failure).
+ """
+ # Build series subset (Material matches; Conditions match or are 'unexposed')
+ try:
+ series_df = FTIR_DataFrame[FTIR_DataFrame["Material"].astype(str) == str(material)].copy()
+ except Exception:
+ series_df = FTIR_DataFrame.copy()
+ # Optionally exclude rows marked as bad quality
+ if not include_bad:
+ try:
+ series_df = series_df[_quality_good_mask(series_df)]
+ except Exception:
+ pass
+ if series_df.empty:
+ return "No spectra found for the selected material.", None
+
+ # Compute union of X-Ranges for this selection (used throughout optimization)
+ nonlocal current_union_x_ranges
+ try:
+ current_union_x_ranges = _collect_union_x_ranges(series_df)
+ except Exception:
+ current_union_x_ranges = []
+
+ # Seed shared parameters by aligning deconvolution peaks to canonical centers
+ peak_lists = []
+ peak_lists_by_idx = {}
+ for _idx, _row in series_df.iterrows():
+ pk = _parse_deconv(_row.get("Deconvolution Results"))
+ if pk is not None and len(pk) > 0:
+ peak_lists.append(pk)
+ peak_lists_by_idx[_idx] = pk
+
+ if not peak_lists:
+ return "Selected series has no usable deconvolution results.", None
+
+ sigma_samples = []
+ all_centers = []
+ for _pk in peak_lists:
+ for p in _pk:
+ try:
+ sval = float(p.get("sigma", p.get("σ", np.nan)))
+ if np.isfinite(sval):
+ sigma_samples.append(sval)
+ except Exception:
+ pass
+ try:
+ cval = float(p.get("center", p.get("center_wavenumber", np.nan)))
+ if np.isfinite(cval):
+ all_centers.append(cval)
+ except Exception:
+ pass
+ try:
+ tol = float(np.nanmedian(sigma_samples)) if np.isfinite(np.nanmedian(sigma_samples)) else 8.0
+ except Exception:
+ tol = 8.0
+
+ try:
+ centers_sorted = sorted(set([float(c) for c in all_centers if np.isfinite(c)]))
+ except Exception:
+ centers_sorted = []
+
+ canonical_centers = []
+ for c in centers_sorted:
+ if not canonical_centers:
+ canonical_centers.append(c)
+ continue
+ if abs(c - canonical_centers[-1]) <= tol:
+ canonical_centers[-1] = (canonical_centers[-1] + c) / 2.0
+ else:
+ canonical_centers.append(c)
+
+ k = len(canonical_centers)
+ if k <= 0:
+ return "Could not establish canonical peaks for the series.", None
+
+ # Align each spectrum to the canonical centers; add missing peaks with amplitude 0
+ aligned_by_idx = {}
+ try:
+ sigma_default = float(np.nanmedian(sigma_samples)) if np.isfinite(np.nanmedian(sigma_samples)) else 10.0
+ except Exception:
+ sigma_default = 10.0
+ for _idx, peaks in peak_lists_by_idx.items():
+ aligned = [None] * k
+ used = set()
+ for i, ccan in enumerate(canonical_centers):
+ best_j = None
+ best_d = float("inf")
+ for j, p in enumerate(peaks):
+ if j in used:
+ continue
+ try:
+ cval = float(p.get("center", p.get("center_wavenumber", np.nan)))
+ except Exception:
+ cval = float("nan")
+ if not np.isfinite(cval):
+ continue
+ d = abs(cval - ccan)
+ if d < best_d:
+ best_d = d
+ best_j = j
+ if best_j is not None and best_d <= tol:
+ aligned[i] = dict(peaks[best_j])
+ used.add(best_j)
+ else:
+ aligned[i] = {
+ "amplitude": 0.0,
+ "center": float(ccan),
+ "alpha": 0.5,
+ "fraction": 0.5,
+ "sigma": float(sigma_default),
+ }
+ aligned_by_idx[_idx] = aligned
+
+ # Track which rows are actually used (usable deconvolution results)
+ nonlocal last_used_fit_row_indices
+ try:
+ last_used_fit_row_indices = set(aligned_by_idx.keys())
+ except Exception:
+ last_used_fit_row_indices = set()
+
+ # Aggregate initial shared params (centers/sigma/alpha)
+ centers_mat, sigmas_mat, fracs_mat = [], [], []
+ for _idx, aligned in aligned_by_idx.items():
+ try:
+ centers_mat.append([float(p.get("center", np.nan)) for p in aligned])
+ sigmas_mat.append([float(p.get("sigma", p.get("σ", np.nan))) for p in aligned])
+ fracs_mat.append([float(p.get("fraction", p.get("alpha", np.nan))) for p in aligned])
+ except Exception:
+ continue
+ if not centers_mat:
+ return "No usable aligned peaks for optimization.", None
+
+ centers_arr = np.asarray(centers_mat, dtype=float)
+ sigmas_arr = np.asarray(sigmas_mat, dtype=float)
+ fracs_arr = np.asarray(fracs_mat, dtype=float)
+ with np.errstate(all="ignore"):
+ cen = np.nanmean(centers_arr, axis=0)
+ sig_l = np.nanmean(sigmas_arr, axis=0)
+ frc = np.nanmean(fracs_arr, axis=0)
+ for i in range(k):
+ if not np.isfinite(cen[i]):
+ vals = centers_arr[:, i]
+ cen[i] = np.nanmedian(vals) if np.isfinite(np.nanmedian(vals)) else float(canonical_centers[i])
+ if not np.isfinite(sig_l[i]):
+ vals = sigmas_arr[:, i]
+ sig_l[i] = np.nanmedian(vals) if np.isfinite(np.nanmedian(vals)) else float(sigma_default)
+ if not np.isfinite(frc[i]):
+ vals = fracs_arr[:, i]
+ frc[i] = np.nanmedian(vals) if np.isfinite(np.nanmedian(vals)) else 0.5
+
+ # Determine global x-bounds across the series
+ try:
+ x_min = float("inf")
+ x_max = float("-inf")
+ for _idx, _row in series_df.iterrows():
+ x_arr, y_arr = _parse_xy(_row)
+ if x_arr is None or y_arr is None or x_arr.size == 0:
+ continue
+ x_min = min(x_min, float(np.nanmin(x_arr)))
+ x_max = max(x_max, float(np.nanmax(x_arr)))
+ if not np.isfinite(x_min) or not np.isfinite(x_max):
+ x_min, x_max = 0.0, 1.0
+ except Exception:
+ x_min, x_max = 0.0, 1.0
+
+ def _build_model_fixed(cen_arr):
+ comp = None
+ params = None
+ for i in range(k):
+ m = PseudoVoigtModel(prefix=f"p{i}_")
+ p = m.make_params()
+ p[f"p{i}_center"].set(value=float(cen_arr[i]), vary=False)
+ p[f"p{i}_sigma"].set(
+ value=float(sig_l[i]), min=1e-3, max=1e4, vary=False
+ )
+ p[f"p{i}_fraction"].set(
+ value=float(frc[i]), min=0.0, max=1.0, vary=False
+ )
+ p[f"p{i}_amplitude"].set(min=0.0, value=1.0)
+ if comp is None:
+ comp = m
+ params = p
+ else:
+ comp = comp + m
+ params.update(p)
+ return comp, params
+
+ def _fit_and_sse(cen_arr, assign=False, capture=None):
+ comp, base = _build_model_fixed(cen_arr)
+ total = 0.0
+ cache = {}
+ for _idx, _row in series_df.iterrows():
+ # Always compute residuals against processed data
+ # Explicitly read from 'X-Axis' and 'Normalized and Corrected Data'
+ x_val = _row.get("X-Axis")
+ y_val = _row.get("Normalized and Corrected Data")
+ if isinstance(x_val, str):
+ try:
+ x_val = ast.literal_eval(x_val)
+ except Exception:
+ x_val = None
+ if isinstance(y_val, str):
+ try:
+ y_val = ast.literal_eval(y_val)
+ except Exception:
+ y_val = None
+ try:
+ x_arr = np.asarray(x_val, dtype=float)
+ y_arr = np.asarray(y_val, dtype=float)
+ if x_arr.ndim != 1 or y_arr.ndim != 1 or x_arr.size != y_arr.size:
+ continue
+ except Exception:
+ continue
+ # Restrict to union x-ranges
+ try:
+ x_use, y_use = _slice_to_union_ranges(x_arr, y_arr, current_union_x_ranges)
+ except Exception:
+ x_use, y_use = x_arr, y_arr
+ if x_use is None or y_use is None or np.asarray(x_use).size <= 1 or np.asarray(y_use).size <= 1:
+ continue
+ x_arr = np.asarray(x_use, dtype=float)
+ y_arr = np.asarray(y_use, dtype=float)
+
+ p = base.copy()
+ aligned = aligned_by_idx.get(_idx)
+ if isinstance(aligned, list) and len(aligned) == k:
+ for i in range(k):
+ try:
+ ai = float(aligned[i].get("amplitude", aligned[i].get("A", p[f"p{i}_amplitude"].value)))
+ p[f"p{i}_amplitude"].set(value=max(0.0, ai))
+ except Exception:
+ pass
+ else:
+ for i in range(k):
+ try:
+ ci = float(cen_arr[i])
+ nearest = int(np.argmin(np.abs(x_arr - ci)))
+ ai0 = max(0.0, float(y_arr[nearest]) * max(1.0, float(sig_l[i])))
+ p[f"p{i}_amplitude"].set(value=ai0)
+ except Exception:
+ pass
+ try:
+ res = comp.fit(y_arr, p, x=x_arr)
+ y_fit = comp.eval(res.params, x=x_arr)
+ err = y_arr - y_fit
+ total += float(np.nansum(err * err))
+ if assign:
+ fit_list = []
+ amps_only = []
+ for j in range(k):
+ try:
+ amp = float(res.params.get(f"p{j}_amplitude").value)
+ except Exception:
+ amp = float("nan")
+ fit_list.append({"amplitude": amp})
+ try:
+ amps_only.append(float(amp) if np.isfinite(amp) else 0.0)
+ except Exception:
+ amps_only.append(0.0)
+ cache[_idx] = fit_list
+ try:
+ FTIR_DataFrame.at[_idx, "Material Fit Results"] = amps_only
+ except Exception:
+ pass
+ except Exception:
+ total += 1e12
+ if assign:
+ if capture is not None:
+ try:
+ capture.clear()
+ capture.update(cache)
+ except Exception:
+ pass
+ return total
+
+ # Initial evaluation: fit amplitudes with seed centers and write results
+ cen_init = cen.copy()
+ cen_curr = cen.copy()
+ init_cache = {}
+ best_sse = _fit_and_sse(cen_curr, assign=True, capture=init_cache)
+ initial_sse = best_sse
+ # Track the centers corresponding to the current best SSE explicitly
+ best_centers = cen_curr.copy()
+
+ # Step size based on sigma scale
+ try:
+ sig_med = (
+ float(np.nanmedian(sig_l)) if np.isfinite(np.nanmedian(sig_l)) else 10.0
+ )
+ except Exception:
+ sig_med = 10.0
+ step = max(0.5, min(10.0, 0.2 * sig_med))
+ min_step = 0.05
+ max_passes = 10
+ tol = 1e-6
+
+ passes_done = 0
+ moves_attempted = 0
+ moves_accepted = 0
+ for _pass in range(max_passes):
+ improved = False
+ for i in range(k):
+ for direction in (-1.0, 1.0):
+ cen_try = cen_curr.copy()
+ cen_try[i] = float(
+ np.clip(cen_try[i] + direction * step, x_min, x_max)
+ )
+ sse_try = _fit_and_sse(cen_try, assign=False)
+ moves_attempted += 1
+ if sse_try + tol < best_sse:
+ cen_curr = cen_try
+ best_sse = sse_try
+ best_centers = cen_try.copy()
+ improved = True
+ moves_accepted += 1
+ break
+ if not improved:
+ step *= 0.5
+ if step < min_step:
+ break
+ passes_done += 1
+
+ # Final amplitudes re-fit and saved using the optimized centers (best found)
+ final_cache = {}
+ # Ensure we evaluate and assign using the best centers discovered
+ cen_curr = best_centers.copy()
+ final_sse = _fit_and_sse(cen_curr, assign=True, capture=final_cache)
+
+ # Update shared params to reflect optimized centers
+ nonlocal shared_centers_list, shared_sigma_list, shared_alpha_list, shared_peak_numbers_list
+ try:
+ shared_centers_list = [float(v) for v in cen_curr.tolist()]
+ except Exception:
+ shared_centers_list = cen_curr.tolist() if hasattr(cen_curr, "tolist") else list(cen_curr)
+ try:
+ shared_sigma_list = [float(v) if np.isfinite(v) else 10.0 for v in sig_l.tolist()]
+ except Exception:
+ shared_sigma_list = [10.0] * k
+ try:
+ shared_alpha_list = [float(np.clip(v, 0.0, 1.0)) if np.isfinite(v) else 0.5 for v in frc.tolist()]
+ except Exception:
+ shared_alpha_list = [0.5] * k
+ try:
+ shared_peak_numbers_list = _compute_shared_peak_numbers_from_aligned(aligned_by_idx, k)
+ except Exception:
+ shared_peak_numbers_list = [None] * k
+ # Report delta: negative means decreased SSE
+ delta = final_sse - initial_sse
+ msg = (
+ f"Optimized centers and amplitudes over {series_df.shape[0]} spectra. SSE: {initial_sse:.6g} -> {final_sse:.6g}"
+ + (f" (Δ={delta:.6g})" if np.isfinite(delta) else "")
+ )
+ # Build detailed summary
+ try:
+ center_deltas = (cen_curr - cen_init).tolist()
+ except Exception:
+ center_deltas = None
+
+ # Compute mean amplitude per peak across spectra (before vs after)
+ def _mean_amps(cache_dict):
+ means = []
+ try:
+ for j in range(k):
+ vals = []
+ for _v in cache_dict.values():
+ try:
+ a = float(_v[j].get("amplitude", float("nan")))
+ if np.isfinite(a):
+ vals.append(a)
+ except Exception:
+ pass
+ means.append(float(np.nanmean(vals)) if len(vals) else float("nan"))
+ except Exception:
+ pass
+ return means
+
+ amp_init_means = _mean_amps(init_cache)
+ amp_final_means = _mean_amps(final_cache)
+ try:
+ amp_delta_means = [
+ (
+ (amp_final_means[i] - amp_init_means[i])
+ if i < len(amp_init_means)
+ and np.isfinite(amp_init_means[i])
+ and np.isfinite(amp_final_means[i])
+ else float("nan")
+ )
+ for i in range(max(len(amp_init_means), len(amp_final_means)))
+ ]
+ except Exception:
+ amp_delta_means = []
+ # Build per-spectrum amplitude deltas (final - initial) for each peak
+ amp_delta_by_spectrum = []
+ try:
+ # Sort spectra by numeric Time if available
+ df_order = series_df.copy()
+ try:
+ df_order["_sort_time"] = pd.to_numeric(
+ df_order.get("Time", np.nan), errors="coerce"
+ )
+ df_order["_sort_time"] = df_order["_sort_time"].fillna(float("inf"))
+ df_order = df_order.sort_values(by=["_sort_time"], kind="mergesort")
+ except Exception:
+ pass
+ for _idx, _row in df_order.iterrows():
+ init_list = init_cache.get(_idx)
+ final_list = final_cache.get(_idx)
+ label = f"T={_row.get('Time')}"
+ try:
+ file_name = _row.get("File Name", "")
+ except Exception:
+ file_name = ""
+ deltas = []
+ if isinstance(init_list, list) and isinstance(final_list, list):
+ for j in range(k):
+ try:
+ a0 = float(init_list[j].get("amplitude", float("nan")))
+ except Exception:
+ a0 = float("nan")
+ try:
+ a1 = float(final_list[j].get("amplitude", float("nan")))
+ except Exception:
+ a1 = float("nan")
+ try:
+ d = (
+ a1 - a0
+ if np.isfinite(a0) and np.isfinite(a1)
+ else float("nan")
+ )
+ except Exception:
+ d = float("nan")
+ deltas.append(d)
+ amp_delta_by_spectrum.append({"label": label, "file_name": file_name, "deltas": deltas})
+ except Exception:
+ amp_delta_by_spectrum = []
+ summary = {
+ "initial_sse": float(initial_sse) if np.isfinite(initial_sse) else None,
+ "final_sse": float(final_sse) if np.isfinite(final_sse) else None,
+ "passes": int(passes_done),
+ "moves_attempted": int(moves_attempted),
+ "moves_accepted": int(moves_accepted),
+ "initial_centers": cen_init.tolist(),
+ "final_centers": cen_curr.tolist(),
+ "center_deltas": center_deltas,
+ "peak_numbers": shared_peak_numbers_list,
+ "amp_initial_means": amp_init_means,
+ "amp_final_means": amp_final_means,
+ "amp_delta_means": amp_delta_means,
+ "amp_delta_by_spectrum": amp_delta_by_spectrum,
+ }
+ return msg, cen_curr.tolist(), summary
+
+ # ---------------------------- UI helpers ----------------------------- #
+ def _series_df(material_val, include_bad=False):
+ df = FTIR_DataFrame.copy()
+ # Optionally exclude rows marked as bad quality
+ if not include_bad:
+ try:
+ df = df[_quality_good_mask(df)]
+ except Exception:
+ pass
+ try:
+ df = df[df["Normalized and Corrected Data"].notna()]
+ except Exception:
+ pass
+ try:
+ df = df[df["Material"].astype(str) == str(material_val)]
+ except Exception:
+ df = df[df.get("Material", "").astype(str) == str(material_val)]
+
+ def _is_unexp(v):
+ try:
+ return str(v).strip().lower() == "unexposed"
+ except Exception:
+ return False
+
+ # No condition filtering; include all spectra of the material
+ try:
+ df = df.copy()
+ df["_sort_time"] = pd.to_numeric(df.get("Time", np.nan), errors="coerce")
+ df["_sort_time"] = df["_sort_time"].fillna(float("inf"))
+ df = df.sort_values(by=["_sort_time"], kind="mergesort")
+ try:
+ df = df.drop(columns=["_sort_time"])
+ except Exception:
+ pass
+ except Exception:
+ pass
+ return df
+
+ def _eval_timeseries_fit(row):
+ x = row.get("X-Axis")
+ y = row.get("Normalized and Corrected Data")
+ if isinstance(x, str):
+ try:
+ x = ast.literal_eval(x)
+ except Exception:
+ return None, None, None
+ if isinstance(y, str):
+ try:
+ y = ast.literal_eval(y)
+ except Exception:
+ return None, None, None
+ try:
+ x_arr = np.asarray(x, dtype=float)
+ y_arr = np.asarray(y, dtype=float)
+ except Exception:
+ return None, None, None
+ # Build fit from amplitude-only results using shared parameters
+ res = row.get("Material Fit Results")
+ if isinstance(res, str):
+ try:
+ res = ast.literal_eval(res)
+ except Exception:
+ res = None
+ amps = None
+ if isinstance(res, list) and len(res) > 0:
+ try:
+ # list of amplitudes
+ amps = [float(v) for v in res]
+ except Exception:
+ amps = None
+ if amps is None or not isinstance(shared_centers_list, list) or not isinstance(shared_sigma_list, list) or not isinstance(shared_alpha_list, list):
+ return x_arr, y_arr, None
+ try:
+ k = min(len(amps), len(shared_centers_list), len(shared_sigma_list), len(shared_alpha_list))
+ comp_model = None
+ params = None
+ for i in range(k):
+ m = PseudoVoigtModel(prefix=f"p{i}_")
+ pr = m.make_params()
+ pr[f"p{i}_center"].set(value=float(shared_centers_list[i]), vary=False)
+ pr[f"p{i}_sigma"].set(value=float(shared_sigma_list[i]), min=1e-3, max=1e4, vary=False)
+ pr[f"p{i}_fraction"].set(value=float(np.clip(shared_alpha_list[i], 0.0, 1.0)), min=0.0, max=1.0, vary=False)
+ pr[f"p{i}_amplitude"].set(value=max(0.0, float(amps[i])), min=0.0)
+ if comp_model is None:
+ comp_model = m
+ params = pr
+ else:
+ comp_model = comp_model + m
+ params.update(pr)
+ y_fit = comp_model.eval(params, x=x_arr) if comp_model is not None else None
+ return x_arr, y_arr, y_fit
+ except Exception:
+ return x_arr, y_arr, None
+
+ # ---------------------------- Build UI ------------------------------- #
+ # Checkbox to include/exclude rows marked as bad quality
+ include_bad_cb = widgets.Checkbox(
+ value=False,
+ description="Include bad spectra",
+ indent=False,
+ layout=widgets.Layout(width="auto"),
+ )
+
+ try:
+ df_opts = FTIR_DataFrame.copy()
+ if not include_bad_cb.value:
+ try:
+ df_opts = df_opts[_quality_good_mask(df_opts)]
+ except Exception:
+ pass
+ try:
+ df_opts = df_opts[df_opts["Normalized and Corrected Data"].notna()]
+ except Exception:
+ pass
+ unique_materials = (
+ sorted(
+ {
+ str(v)
+ for v in df_opts.get("Material", pd.Series([], dtype=object))
+ .dropna()
+ .astype(str)
+ .unique()
+ .tolist()
+ }
+ )
+ if "Material" in df_opts.columns
+ else []
+ )
+ except Exception:
+ unique_materials = []
+ if not unique_materials:
+ raise ValueError("No materials found in DataFrame.")
+ # Choose initial material from session defaults when available
+ default_material = unique_materials[0]
+ try:
+ _sess_defaults = _get_session_defaults()
+ _sess_mat = str(_sess_defaults.get("material", "any"))
+ if _sess_mat in unique_materials:
+ default_material = _sess_mat
+ except Exception:
+ pass
+ try:
+ dfm = FTIR_DataFrame[
+ FTIR_DataFrame["Material"].astype(str) == str(default_material)
+ ]
+ except Exception:
+ dfm = FTIR_DataFrame
+ # Optionally exclude bad quality rows and require normalized data for condition options
+ if not include_bad_cb.value:
+ try:
+ dfm = dfm[_quality_good_mask(dfm)]
+ except Exception:
+ pass
+ try:
+ dfm = dfm[dfm["Normalized and Corrected Data"].notna()]
+ except Exception:
+ pass
+
+ material_dd = widgets.Dropdown(
+ options=unique_materials,
+ value=default_material,
+ description="Material",
+ layout=widgets.Layout(width="40%"),
+ )
+ fit_btn = widgets.Button(
+ description="Fit Material",
+ button_style="primary",
+ layout=widgets.Layout(width="180px"),
+ tooltip="Find parameter averages (preserving existing amplitudes) for the selected Material",
+ )
+ opt_btn = widgets.Button(
+ description="Optimize",
+ button_style="info",
+ layout=widgets.Layout(width="180px"),
+ tooltip=(
+ "Iteratively optimize shared peak centers and per-spectrum amplitudes to "
+ "minimize SSE against Normalized and Corrected Data"
+ ),
+ )
+ close_btn = widgets.Button(description="Close", button_style="danger")
+ status_html = widgets.HTML(value="")
+ x_ranges_html = widgets.HTML(value="")
+ optimize_status_html = widgets.HTML(value="")
+ # Tables: Peak Areas (per-time amplitudes) and Peak Wavenumbers (shared centers)
+ A_table_html = widgets.HTML(value="")
+ WN_table_html = widgets.HTML(value="")
+ # Store the most recently built tables for optional export
+ last_table_df = None # areas
+ last_centers_list = None # wavenumbers (list[float])
+
+ # Plotting removed per request; keep tables and controls only
+
+ def _plot_series(
+ material_val=None, condition_val=None, with_fits=False, include_bad=None
+ ):
+ nonlocal last_table_df, last_centers_list
+ # No plotting; only build tables and status
+ if material_val is None:
+ material_val = material_dd.value
+ if include_bad is None:
+ include_bad = include_bad_cb.value
+ # _series_df accepts (material_val, include_bad) — no conditions argument
+ df_series = _series_df(material_val, include_bad=include_bad)
+ if df_series.empty:
+ try:
+ status_html.value = (
+ "No spectra for this selection."
+ )
+ except Exception:
+ pass
+ try:
+ A_table_html.value = ""
+ except Exception:
+ pass
+ try:
+ WN_table_html.value = ""
+ except Exception:
+ pass
+ return
+ # Build a consistent color palette (blue → purple → red) based on time values,
+ # matching the gradient used in plot_spectra
+ time_values = []
+ try:
+ time_values = [
+ t for t in df_series.get("Time", pd.Series([], dtype=object)) if pd.notna(t)
+ ]
+ except Exception:
+ time_values = []
+ try:
+ time_values_unique = sorted(
+ {float(t) for t in time_values if str(t).strip() not in ("", "nan")}
+ )
+ except Exception:
+ # Fallback to string sorting
+ time_values_unique = sorted({str(t) for t in time_values})
+
+ def _time_to_color(val):
+ return _time_gradient_color(time_values_unique, val)
+
+ # Only show final time-series fits (no raw data traces)
+ has_any_fit = False
+ for idx, row in df_series.iterrows():
+ if not with_fits:
+ continue
+ x_f, _y_f, y_fit = _eval_timeseries_fit(row)
+ if y_fit is None or x_f is None:
+ continue
+ has_any_fit = True
+ t_val = row.get("Time")
+ name = f"T={t_val}"
+ # Plotting removed
+ # Build/update wavenumbers (shared centers), sigmas, alphas table and amplitude table
+ try:
+ if with_fits and has_any_fit:
+ # Use shared canonical parameters (centers/sigmas/alphas)
+ centers_list = shared_centers_list or []
+ sigmas_list = shared_sigma_list or []
+ fracs_list = shared_alpha_list or []
+ peak_numbers_list = shared_peak_numbers_list or []
+
+ if centers_list and len(centers_list) > 0:
+ try:
+ import pandas as pd # local import safe here
+
+ # Build a table with rows: Center, Sigma (σ), Alpha (Lorentz); columns: Peak 1..N
+ k = len(centers_list)
+ header = _peak_labels_from_numbers(peak_numbers_list, k)
+
+ def _fmt(v, fmt=".6g"):
+ try:
+ return f"{float(v):{fmt}}" if np.isfinite(v) else ""
+ except Exception:
+ return ""
+
+ rows = [
+ ["Center (cm⁻¹)"]
+ + [_fmt(centers_list[i]) for i in range(k)],
+ ["σ (cm⁻¹)"]
+ + [
+ _fmt(
+ (
+ sigmas_list[i]
+ if sigmas_list and i < len(sigmas_list)
+ else float("nan")
+ )
+ )
+ for i in range(k)
+ ],
+ ["α (Lorentz frac)"]
+ + [
+ _fmt(
+ (
+ fracs_list[i]
+ if fracs_list and i < len(fracs_list)
+ else float("nan")
+ )
+ )
+ for i in range(k)
+ ],
+ ]
+ wn_df = pd.DataFrame(rows, columns=["Parameter"] + header)
+ html_wn = wn_df.to_html(index=False, escape=False)
+ WN_table_html.value = (
+ "Peak Parameters
"
+ + f"{html_wn}
"
+ )
+ last_centers_list = [
+ (
+ float(c)
+ if isinstance(c, (int, float)) and np.isfinite(c)
+ else float("nan")
+ )
+ for c in centers_list
+ ]
+ except Exception:
+ # Fallback manual HTML
+ k = len(centers_list or [])
+ header_cells_wn = "".join(
+ [f"Parameter | "]
+ + [f"{h} | " for h in _peak_labels_from_numbers(peak_numbers_list, k)]
+ )
+
+ def _cell(v, fmt=".6g"):
+ try:
+ return (
+ f"{float(v):{fmt}} | "
+ if np.isfinite(v)
+ else " | "
+ )
+ except Exception:
+ return " | "
+
+ row_center = "".join(
+ ["Center (cm⁻¹) | "]
+ + [_cell(c) for c in (centers_list or [])]
+ )
+ row_sigma = "".join(
+ ["σ (cm⁻¹) | "]
+ + [
+ _cell(
+ sigmas_list[i]
+ if sigmas_list and i < len(sigmas_list)
+ else float("nan")
+ )
+ for i in range(k)
+ ]
+ )
+ row_alpha = "".join(
+ ["α (Lorentz frac) | "]
+ + [
+ _cell(
+ fracs_list[i]
+ if fracs_list and i < len(fracs_list)
+ else float("nan")
+ )
+ for i in range(k)
+ ]
+ )
+ WN_table_html.value = (
+ "Peak Parameters
"
+ + ""
+ + f"
{header_cells_wn}
"
+ + f"{row_center}
{row_sigma}
{row_alpha}
"
+ + "
"
+ + "
Peak Areas
"
+ + f"{html}
"
+ )
+ # Keep a copy for saving
+ try:
+ last_table_df = df_table.copy()
+ except Exception:
+ last_table_df = df_table
+ except Exception:
+ # Fallback manual HTML
+ peak_headers = _peak_labels_from_numbers(peak_numbers_list, k_max)
+ header_cells = "".join(
+ ["File Name | ", "Time | ", "Conditions | "]
+ + [f"{peak_headers[i] if i < len(peak_headers) else f'Peak {i+1}'} | " for i in range(k_max)]
+ + ["Notes | "]
+ )
+ body_rows = []
+ for t_val, cond_val, file_name_val, amps, notes in series_rows:
+ cells = [
+ f"{file_name_val if file_name_val is not None else ''} | ",
+ f"{t_val} | ",
+ f"{cond_val if cond_val is not None else ''} | ",
+ ]
+ for i in range(k_max):
+ try:
+ if (
+ amps is not None
+ and i < len(amps)
+ and np.isfinite(amps[i])
+ ):
+ cells.append(f"{amps[i]:.6g} | ")
+ else:
+ cells.append(" | ")
+ except Exception:
+ cells.append(" | ")
+ # Notes cell
+ try:
+ cells.append(f"{notes} | ")
+ except Exception:
+ cells.append(" | ")
+ body_rows.append(f"{''.join(cells)}
")
+ A_table_html.value = (
+ "Peak Areas
"
+ + ""
+ + f"
{header_cells}
{''.join(body_rows)}
"
+ + "
{msg}
"
+ except Exception:
+ pass
+ else:
+ status_html.value = f"{msg}"
+ # Build a persistent, detailed optimization log
+ try:
+ # Compute SSE AFTER optimization using updated fits stored in the DataFrame
+ try:
+ sse_after_calc = _series_sse(material_dd.value)
+ except Exception:
+ sse_after_calc = float("nan")
+ if summary is None:
+ optimize_status_html.value = (
+ f"Optimization: {msg}
"
+ )
+ else:
+ # Compose a compact table of per-peak changes
+ centers0 = summary.get("initial_centers", []) or []
+ centers1 = summary.get("final_centers", []) or []
+ deltas = summary.get("center_deltas", []) or []
+ peak_nums = summary.get("peak_numbers", []) or []
+ peak_labels = _peak_labels_from_numbers(peak_nums, klen)
+ amp0 = summary.get("amp_initial_means", []) or []
+ amp1 = summary.get("amp_final_means", []) or []
+ ampd = summary.get("amp_delta_means", []) or []
+ rows = []
+ klen = max(len(centers0), len(centers1), len(deltas))
+ for i in range(klen):
+ c0 = centers0[i] if i < len(centers0) else None
+ c1 = centers1[i] if i < len(centers1) else None
+ dd = deltas[i] if i < len(deltas) else None
+
+ def _fmt(v):
+ try:
+ return f"{float(v):.6g}"
+ except Exception:
+ return ""
+
+ rows.append(
+ f"| {peak_labels[i] if i < len(peak_labels) else f'Peak {i+1}'} | {_fmt(c0)} | {_fmt(c1)} | {_fmt(dd)} |
"
+ )
+ table_html = (
+ ""
+ " | Initial center | Final center | Δ center |
|---|
"
+ f"{''.join(rows)}
"
+ )
+ # Amplitude change table by spectrum (Δ per peak)
+ delta_by_spec = summary.get("amp_delta_by_spectrum", []) or []
+ # Determine max number of peaks to render
+ kmax = 0
+ for item in delta_by_spec:
+ try:
+ kmax = max(kmax, len(item.get("deltas", [])))
+ except Exception:
+ pass
+ # Build header and body rows
+ header_cells = "".join(
+ ["File Name | ", "Series | "]
+ + [f"{(peak_labels[i] if i < len(peak_labels) else f'Peak {i+1}')} Δ | " for i in range(kmax)]
+ )
+ body_rows = []
+
+ def _fmtd(v):
+ try:
+ return f"{float(v):.6g}"
+ except Exception:
+ return ""
+
+ for item in delta_by_spec:
+ label = item.get("label", "")
+ file_name = item.get("file_name", "")
+ deltas = item.get("deltas", []) or []
+ cells = [f"{file_name} | ", f"{label} | "]
+ for i in range(kmax):
+ val = deltas[i] if i < len(deltas) else None
+ cells.append(f"{_fmtd(val)} | ")
+ body_rows.append(f"{''.join(cells)}
")
+ amp_table_html = (
+ ""
+ f"{header_cells}
"
+ f"{''.join(body_rows)}
"
+ )
+ # Prefer recomputed SSE for consistent selection and evaluation; fallback to optimizer-reported values
+ sse0 = (
+ sse_before_calc
+ if np.isfinite(sse_before_calc)
+ else summary.get("initial_sse")
+ )
+ if sse0 is None or not np.isfinite(sse0):
+ sse0 = None
+ sse1 = (
+ sse_after_calc
+ if np.isfinite(sse_after_calc)
+ else summary.get("final_sse")
+ )
+ if sse1 is None or not np.isfinite(sse1):
+ sse1 = None
+ try:
+ # Display delta as (final - initial): negative means decreased SSE
+ delta_disp = (
+ (sse1 - sse0)
+ if (sse0 is not None and sse1 is not None)
+ else None
+ )
+ except Exception:
+ delta_disp = None
+ passes_done = summary.get("passes")
+ m_att = summary.get("moves_attempted")
+ m_acc = summary.get("moves_accepted")
+ optimize_status_html.value = (
+ "Optimization Summary
"
+ + (
+ f"SSE: {sse0:.6g} → {sse1:.6g} (Δ={delta_disp:.6g}) | Passes: {passes_done} | Moves: {m_acc}/{m_att} accepted
"
+ if (sse0 is not None and sse1 is not None)
+ else f"Passes: {passes_done} | Moves: {m_acc}/{m_att} accepted
"
+ )
+ + "(Amplitudes re-fit per spectrum during optimization)
"
+ + f"Peak Centers
"
+ + f"{table_html}
"
+ + f"Amplitude Changes by Spectrum (Δ = final − initial)
"
+ + f"{amp_table_html}
"
+ )
+ except Exception:
+ pass
+ except Exception as e:
+ try:
+ status_html.value = (
+ f"Optimize failed: {e}"
+ )
+ except Exception:
+ pass
+ return
+
+ _plot_series(with_fits=True, include_bad=include_bad_cb.value)
+
+ def _on_save_click(_b=None):
+ """Save amplitudes to DataFrame; write σ and α to materials.json for the selected material."""
+ try:
+ mat = str(material_dd.value)
+ cond = None
+ except Exception:
+ mat = "material"
+ cond = "condition"
+ # Build a fresh table to ensure we capture latest amplitudes, independent of UI
+ df_series = _series_df(mat, include_bad=include_bad_cb.value)
+ if df_series.empty:
+ try:
+ status_html.value = "Nothing to save for this selection."
+ except Exception:
+ pass
+ return
+
+ # Only save for rows that were actually used in the fit/optimization.
+ # (i.e., had usable Deconvolution Results that contributed to the canonical peak set)
+ nonlocal last_used_fit_row_indices
+ used_idx = set()
+ try:
+ used_idx = set(int(i) for i in (last_used_fit_row_indices or set()))
+ except Exception:
+ used_idx = set()
+
+ # Fallback inference when user clicks Save without running Fit/Optimize this session
+ if not used_idx:
+ try:
+ for _idx, _row in df_series.iterrows():
+ pk = _parse_deconv(_row.get("Deconvolution Results"))
+ if pk is not None and len(pk) > 0:
+ used_idx.add(int(_idx))
+ except Exception:
+ used_idx = set()
+
+ try:
+ df_series = df_series.loc[df_series.index.intersection(sorted(used_idx))]
+ except Exception:
+ pass
+
+ if df_series.empty:
+ try:
+ status_html.value = "Nothing to save: no rows with usable Deconvolution Results were used in the fit."
+ except Exception:
+ pass
+ return
+ # Determine peak count and build records for areas
+ k_max = 0
+ for _idx, _row in df_series.iterrows():
+ res = _row.get("Material Fit Results")
+ if isinstance(res, str):
+ try:
+ res = ast.literal_eval(res)
+ except Exception:
+ res = None
+ if isinstance(res, list) and len(res) > 0:
+ try:
+ # amplitude-only
+ amps = [float(a) for a in res]
+ k_max = max(k_max, len(amps))
+ except Exception:
+ amps = None
+ else:
+ amps = None
+ if k_max <= 0:
+ try:
+ status_html.value = "No fitted peaks to save for this selection."
+ except Exception:
+ pass
+ return
+ # Persist amplitudes back into 'Material Fit Results'
+ try:
+ dest_col = "Material Fit Results"
+ if dest_col not in FTIR_DataFrame.columns:
+ try:
+ FTIR_DataFrame[dest_col] = None
+ except Exception:
+ pass
+ try:
+ FTIR_DataFrame[dest_col] = FTIR_DataFrame[dest_col].astype(object)
+ except Exception:
+ pass
+
+ updated = 0
+ for idx, _row in df_series.iterrows():
+ res = _row.get(dest_col)
+ if isinstance(res, str):
+ try:
+ res = ast.literal_eval(res)
+ except Exception:
+ res = None
+ if isinstance(res, list) and len(res) > 0:
+ try:
+ FTIR_DataFrame.at[idx, dest_col] = [float(a) for a in res]
+ updated += 1
+ except Exception:
+ pass
+ try:
+ status_html.value = f"Saved per-row peak amplitudes to '{dest_col}' for {updated} row(s) used in the fit."
+ except Exception:
+ pass
+ # --- JSON update: write σ and α for canon peaks of this material --- #
+ try:
+ path, content = _load_materials_json()
+ if content is None or not isinstance(content, list) or not content:
+ raise ValueError("materials.json unavailable")
+ top = content[0]
+ code_key = _lookup_material_code(top, mat)
+ if code_key is None:
+ print(f"[fit_material] Material '{mat}' not found in materials.json; skip JSON update.")
+ else:
+ mat_payload = top.get(code_key, {}) or {}
+ peaks_payload = mat_payload.get("peaks", {}) or {}
+ kjson = len(shared_centers_list or [])
+ # Use peak numbers sourced from Deconvolution Results, falling back to 1..N
+ peak_nums = shared_peak_numbers_list or [None] * kjson
+ for i in range(kjson):
+ try:
+ pn = peak_nums[i] if i < len(peak_nums) else None
+ except Exception:
+ pn = None
+ key = str(int(pn)) if pn is not None else str(i + 1)
+ entry = peaks_payload.get(key, {})
+ # Update center/σ/α using the newest shared fit values
+ try:
+ entry["center_wavenumber"] = float(shared_centers_list[i])
+ except Exception:
+ entry["center_wavenumber"] = entry.get("center_wavenumber", 0.0)
+ try:
+ entry["σ"] = float(shared_sigma_list[i])
+ except Exception:
+ entry["σ"] = entry.get("σ", 0.0)
+ try:
+ entry["α"] = float(shared_alpha_list[i])
+ except Exception:
+ entry["α"] = entry.get("α", 0.0)
+ peaks_payload[key] = entry
+ mat_payload["peaks"] = peaks_payload
+ top[code_key] = mat_payload
+ # Write file
+ try:
+ with open(path, "w", encoding="utf-8") as jf:
+ json.dump(content, jf, indent=4, ensure_ascii=False)
+ print(f"[fit_material] materials.json updated (σ, α) for {mat}.")
+ except Exception as _je:
+ print(f"[fit_material] Failed to write materials.json: {_je}")
+ except Exception as _json_err:
+ print(f"[fit_material] JSON update skipped: {_json_err}")
+ except Exception as e:
+ try:
+ status_html.value = f"Failed to save per-row results: {e}"
+ except Exception:
+ pass
+
+ def _on_close(_b=None):
+ try:
+ material_dd.close()
+ fit_btn.close()
+ close_btn.close()
+ status_html.close()
+ optimize_status_html.close()
+ ui.close()
+ # No figure to close
+ except Exception:
+ pass
+
+ def _refresh_materials_and_conditions():
+ """Recompute material options based on include_bad toggle and current data."""
+ try:
+ df_opts_local = FTIR_DataFrame.copy()
+ if not include_bad_cb.value:
+ try:
+ df_opts_local = df_opts_local[_quality_good_mask(df_opts_local)]
+ except Exception:
+ pass
+ try:
+ df_opts_local = df_opts_local[
+ df_opts_local["Normalized and Corrected Data"].notna()
+ ]
+ except Exception:
+ pass
+ new_materials = (
+ sorted(
+ {
+ str(v)
+ for v in df_opts_local.get(
+ "Material", pd.Series([], dtype=object)
+ )
+ .dropna()
+ .astype(str)
+ .unique()
+ .tolist()
+ }
+ )
+ if "Material" in df_opts_local.columns
+ else []
+ )
+ except Exception:
+ new_materials = []
+ # Update materials dropdown
+ try:
+ cur_mat = (
+ material_dd.value
+ if material_dd.value in getattr(material_dd, "options", [])
+ else None
+ )
+ material_dd.options = new_materials
+ if not new_materials:
+ return
+ if cur_mat not in new_materials:
+ material_dd.value = new_materials[0]
+ except Exception:
+ pass
+ # Re-plot
+ _plot_series(with_fits=False, include_bad=include_bad_cb.value)
+
+ def _on_include_bad_toggle(*_):
+ _refresh_materials_and_conditions()
+
+ material_dd.observe(_on_material_change, names="value")
+
+ # Persist Material/Conditions selections to session
+ def _persist_ts_filters(_=None):
+ try:
+ _set_session_selection(material=material_dd.value)
+ except Exception:
+ pass
+
+ material_dd.observe(_persist_ts_filters, names="value")
+ fit_btn.on_click(_on_fit_click)
+ opt_btn.on_click(_on_optimize_click)
+ include_bad_cb.observe(_on_include_bad_toggle, names="value")
+ # Add Save button to save per-row results (wavenumbers + areas) back into 'Material Fit Results'
+ save_btn = widgets.Button(
+ description="Save",
+ button_style="success",
+ layout=widgets.Layout(width="120px"),
+ tooltip="Save per-row peak parameters to 'Material Fit Results'",
+ )
+ save_btn.on_click(_on_save_click)
+ close_btn.on_click(_on_close)
+
+ # Keep dropdowns/checkbox in one row; buttons in a separate row
+ controls = widgets.HBox([material_dd, include_bad_cb])
+ buttons = widgets.HBox([fit_btn, opt_btn, save_btn, close_btn])
+ ui = widgets.VBox([controls, buttons, status_html, x_ranges_html, optimize_status_html])
+ display(ui, WN_table_html, A_table_html)
+ # Ensure options reflect current include_bad state
+ _refresh_materials_and_conditions()
+ _plot_series(with_fits=False, include_bad=include_bad_cb.value)
+
+ return FTIR_DataFrame
+
+
+def check_fit_quality(FTIR_DataFrame):
+ """Interactive review of material fit quality.
+
+ - Presents a dropdown to select a material.
+ - When selected, checks if the material has entries in the
+ 'Material Fit Results' column.
+ - If none, shows a message prompting to run 'fit_material' first.
+ - If present, computes error between the stored Fit and the
+ 'Normalized and Corrected Data' for each spectrum, and displays
+ a list sorted by ascending error to quickly identify poor fits.
+
+ Returns the DataFrame unchanged.
+ """
+
+ _require_columns(
+ FTIR_DataFrame,
+ [
+ "Material",
+ "X-Axis",
+ "Normalized and Corrected Data",
+ "Material Fit Results",
+ "File Name",
+ "Conditions",
+ "Time",
+ ],
+ context="check_fit_quality",
+ )
+
+ try:
+ materials, _conds = _extract_material_condition_lists(FTIR_DataFrame)
+ except Exception:
+ materials = []
+
+ from IPython.display import display, clear_output # type: ignore
+ if widgets is None:
+ if not materials:
+ print("No materials found. Populate the DataFrame first.")
+ return FTIR_DataFrame
+ print("Widgets not available; showing per-material fit quality summary:")
+ for mat in materials:
+ _check_fit_quality_material(FTIR_DataFrame, mat, _print_only=True)
+ return FTIR_DataFrame
+
+ material_options = ["Select material..."] + (materials or [])
+ dropdown = widgets.Dropdown(options=material_options, description="Material:", layout=widgets.Layout(width="400px"))
+ out = widgets.Output()
+ # Persistent status/output area that must remain after Close
+ top_status_out = widgets.Output()
+ # Track per-session changes to emit a meaningful summary on Close
+ session_changes = {"quality": []}
+ # Show brief instructions initially (will be replaced with session summary on Close)
+ try:
+ _emit_function_summary(
+ top_status_out,
+ [
+ "Choose a material to review fit quality.",
+ "Click Close to end and view session summary.",
+ ],
+ title="Quality Check",
+ )
+ except Exception:
+ with top_status_out:
+ print("Quality Check: choose a material, or Close to hide the UI.")
+ close_top_btn = widgets.Button(description="Close", button_style="danger", layout=widgets.Layout(width="100px"))
+ ui = widgets.VBox([widgets.HBox([close_top_btn, dropdown]), out])
+
+ def on_material_change(change):
+ if change.get("name") != "value":
+ return
+ sel = change.get("new")
+ # Ensure only material-level messages are shown; clear the top status
+ try:
+ with top_status_out:
+ clear_output()
+ except Exception:
+ pass
+ with out:
+ clear_output()
+ if not sel or str(sel).strip() == "Select material...":
+ print("Select a material from the dropdown.")
+ return
+ _check_fit_quality_material(FTIR_DataFrame, sel, _print_only=False, _changes=session_changes)
+
+ def _on_top_close(_b=None):
+ try:
+ dropdown.close()
+ except Exception:
+ pass
+ try:
+ out.clear_output()
+ out.close()
+ except Exception:
+ pass
+ try:
+ close_top_btn.close()
+ except Exception:
+ pass
+ try:
+ ui.close()
+ except Exception:
+ pass
+ # Leave top_status_out visible but replace its content with a session summary
+ # Build and emit session summary based on collected changes
+ try:
+ with top_status_out:
+ clear_output()
+ except Exception:
+ pass
+ try:
+ lines = _session_summary_lines(session_changes, context="Quality Check")
+ except Exception:
+ lines = [
+ "Quality Check session closed.",
+ ]
+ try:
+ _emit_function_summary(
+ top_status_out,
+ lines,
+ title="Session Summary (Quality Check)",
+ )
+ except Exception:
+ # Fallback to plain print if helpers are unavailable
+ try:
+ with top_status_out:
+ print("Quality Check session closed.")
+ except Exception:
+ pass
+
+ close_top_btn.on_click(_on_top_close)
+ dropdown.observe(on_material_change, names="value")
+ display(ui, top_status_out)
+ return FTIR_DataFrame
+
+
+def _check_fit_quality_material(FTIR_DataFrame, material: str, _print_only: bool = False, _changes: dict | None = None):
+ """Compute and display per-spectrum fit errors for a single material.
+
+ - If no usable fit data exists for the material, prints a clear message.
+ - Otherwise, displays a sorted table of spectra by RMSE between Fit and
+ 'Normalized and Corrected Data'.
+ - When _print_only is True, prints textual summary instead of a table.
+ """
+ import numpy as np # type: ignore
+ import pandas as pd # type: ignore
+ from IPython.display import display # type: ignore
+
+ try:
+ mat_mask = (
+ FTIR_DataFrame["Material"].astype(str).str.lower()
+ == str(material).strip().lower()
+ )
+ except Exception:
+ mat_mask = []
+ subset = FTIR_DataFrame.loc[mat_mask] if len(getattr(FTIR_DataFrame, "index", [])) > 0 else FTIR_DataFrame
+ if subset is None or len(subset) == 0:
+ print(f"No spectra found for material '{material}'.")
+ return
+
+ errors = []
+ any_fit_present = False
+
+ def _fit_cell_is_empty(val) -> bool:
+ """Return True when the Material Fit Results cell should be treated as empty.
+
+ Handles None, NaN, blank strings, empty literals ("[]", "{}"), and common
+ textual placeholders like "none", "null", "nan" (case-insensitive).
+ """
+ try:
+ import pandas as _pd # local to avoid top-level dependency changes
+ if val is None or (isinstance(val, float) and math.isnan(val)):
+ return True
+ if isinstance(val, str):
+ s = val.strip().lower()
+ if s in {"", "none", "null", "nan"}:
+ return True
+ if s in {"[]", "{}"}:
+ return True
+ if isinstance(val, (list, tuple, dict)) and len(val) == 0:
+ return True
+ if '_pd' in locals() and _pd.isna(val):
+ return True
+ except Exception:
+ pass
+ return False
+
+ for idx, row in subset.iterrows():
+ x = _parse_seq(row.get("X-Axis"))
+ y = _parse_seq(row.get("Normalized and Corrected Data"))
+ mfr_raw = row.get("Material Fit Results")
+ mfr = _safe_literal_eval(mfr_raw, value_name="Material Fit Results")
+
+ note = ""
+ err = np.inf
+ y_fit = None
+
+ if not _fit_cell_is_empty(mfr_raw):
+ any_fit_present = True
+
+ try:
+ if isinstance(mfr, dict):
+ for key in ("fit_y", "y_fit", "fit", "y"):
+ if key in mfr:
+ y_fit = _parse_seq(mfr[key])
+ break
+ elif isinstance(mfr, list):
+ # Reconstruct composite using lmfit's PseudoVoigtModel components
+ components = []
+ for comp in mfr:
+ if not isinstance(comp, dict):
+ continue
+ try:
+ A = float(comp.get("amplitude", comp.get("A", 0)) or 0.0)
+ c = float(comp.get("center", comp.get("c", np.nan)) or np.nan)
+ s_val = comp.get("sigma", comp.get("sigma_g", comp.get("sigma_l", None)))
+ s = float(s_val) if s_val is not None else np.nan
+ frac_val = comp.get("alpha", comp.get("fraction", comp.get("f", None)))
+ frac = float(frac_val) if frac_val is not None else 0.5
+ except Exception:
+ continue
+ if np.isfinite(A) and np.isfinite(c) and np.isfinite(s) and s > 0 and np.isfinite(frac):
+ components.append((A, c, s, frac))
+
+ if x is not None and y is not None and components:
+ try:
+ xx = np.array(x, dtype=float)
+ # Build composite model and parameters
+ model = None
+ params = None
+ for i, (A, c, s, frac) in enumerate(components, start=1):
+ pv = PseudoVoigtModel(prefix=f"p{i}_")
+ model = pv if model is None else model + pv
+ p = pv.make_params()
+ p[f"p{i}_amplitude"].set(value=max(A, 0.0), min=0.0)
+ p[f"p{i}_center"].set(value=c)
+ p[f"p{i}_sigma"].set(value=max(s, 1e-9), min=1e-12)
+ # alpha in [0,1]
+ alpha_val = min(max(frac, 0.0), 1.0)
+ p[f"p{i}_fraction"].set(value=alpha_val, min=0.0, max=1.0)
+ params = p if params is None else params.update(p)
+ yy = model.eval(params=params, x=xx)
+ y_fit = yy.tolist()
+ except Exception:
+ # Fall back to None so error handling notes it as unusable
+ y_fit = None
+ except Exception:
+ note = "fit data parse error"
+
+ if (
+ y_fit is None
+ or y is None
+ or x is None
+ or len(y) != len(x)
+ or len(y_fit) != len(x)
+ ):
+ if _fit_cell_is_empty(mfr_raw):
+ note = note or "fit not ran"
+ else:
+ note = note or "unusable fit"
+ err = np.inf
+ else:
+ arr_y = np.array(y, dtype=float)
+ arr_fit = np.array(y_fit, dtype=float)
+ dif = arr_y - arr_fit
+ err = float(np.sqrt(np.mean(dif ** 2)))
+
+ errors.append(
+ {
+ "Index": idx,
+ "File Name": row.get("File Name", ""),
+ "Conditions": row.get("Conditions", ""),
+ "Time": row.get("Time", ""),
+ "Error": err,
+ "Note": note,
+ }
+ )
+
+ if not any_fit_present:
+ print(
+ f"No Material Fit Results found for material '{material}'. Please run 'fit_material' first."
+ )
+ return
+
+ df_sorted = pd.DataFrame(errors)
+ # Split into usable (finite error) and excluded (infinite or missing)
+ finite_mask = np.isfinite(df_sorted["Error"].to_numpy()) if not df_sorted.empty else np.array([])
+ df_finite = df_sorted[finite_mask] if finite_mask.size else df_sorted.iloc[0:0]
+ df_excluded = df_sorted[~finite_mask] if finite_mask.size else df_sorted
+ if df_sorted.empty or df_finite.empty:
+ print(
+ f"Fit results exist but are unusable for material '{material}'. Please re-run 'fit_material' or inspect deconvolution parameters."
+ )
+ return
+
+ # Sort the usable rows by ascending error
+ df_sorted = df_finite.sort_values(by="Error", ascending=True)
+
+ if _print_only:
+ print(f"Material: {material}")
+ print("Worst-fitting spectra (ascending RMSE):")
+ for _, r in df_sorted.iterrows():
+ print(
+ f" idx={r['Index']} | time={r['Time']} | cond={r['Conditions']} | err={r['Error']:.6f} | file='{r['File Name']}'"
+ )
+ else:
+ # Build an interactive list with Plot buttons for rows having finite error
+ try:
+ import ipywidgets as widgets # local import for notebook UI
+ from IPython.display import display
+ except Exception:
+ display(df_sorted)
+ return
+
+ # Output areas: plotting overlays and persistent status messages
+ plot_out = widgets.Output()
+ status_out = widgets.Output() # persistent session summary / status
+ excluded_out = widgets.Output() # separate area for excluded list (toggle)
+ # Seed initial instruction using universal emit helper
+ _emit_function_summary(
+ status_out,
+ [
+ "Select a row and click Plot to view overlay.",
+ "Use Mark buttons to set quality.",
+ ],
+ title="Session Summary (Quality Check)",
+ )
+ # Track currently plotted row index for quality marking
+ current_plot_idx = {"idx": None}
+ # Quality controls bound to the currently plotted row
+ mark_bad_btn, mark_good_btn, refresh_quality = _make_quality_controls(
+ FTIR_DataFrame,
+ row_getter=lambda: (
+ FTIR_DataFrame.loc[current_plot_idx["idx"]]
+ if current_plot_idx["idx"] is not None
+ else None
+ ),
+ margin="8px 10px 0 0",
+ status_out=status_out,
+ )
+ # Record quality mark changes into session changes for summary on Close
+ def _record_mark(status: str):
+ try:
+ idx = current_plot_idx.get("idx")
+ except Exception:
+ idx = None
+ if _changes is not None and idx is not None:
+ try:
+ lst = _changes.setdefault("quality", [])
+ lst.append((idx, status))
+ except Exception:
+ pass
+
+ mark_bad_btn.on_click(lambda _b=None: _record_mark("bad"))
+ mark_good_btn.on_click(lambda _b=None: _record_mark("good"))
+
+ def _get_xy_and_fit(row_idx):
+ try:
+ row = FTIR_DataFrame.loc[row_idx]
+ except Exception:
+ return None, None, None, None
+ # Parse x and y
+ x = _parse_seq(row.get("X-Axis"))
+ y = _parse_seq(row.get("Normalized and Corrected Data"))
+ # Parse fit cell
+ mfr_raw = row.get("Material Fit Results")
+ mfr = _safe_literal_eval(mfr_raw, value_name="Material Fit Results")
+ y_fit = None
+ try:
+ if isinstance(mfr, dict):
+ for key in ("fit_y", "y_fit", "fit", "y"):
+ if key in mfr:
+ y_fit = _parse_seq(mfr[key])
+ break
+ elif isinstance(mfr, list):
+ # Reconstruct composite fit using lmfit PseudoVoigtModel
+ comps = []
+ for comp in mfr:
+ if not isinstance(comp, dict):
+ continue
+ try:
+ A = float(comp.get("amplitude", comp.get("A", 0)) or 0.0)
+ c = float(comp.get("center", comp.get("c", np.nan)) or np.nan)
+ s_val = comp.get("sigma", comp.get("sigma_g", comp.get("sigma_l", None)))
+ s = float(s_val) if s_val is not None else np.nan
+ frac_val = comp.get("alpha", comp.get("fraction", comp.get("f", None)))
+ frac = float(frac_val) if frac_val is not None else 0.5
+ except Exception:
+ continue
+ if np.isfinite(A) and np.isfinite(c) and np.isfinite(s) and s > 0 and np.isfinite(frac):
+ comps.append((A, c, s, frac))
+ if x is not None and comps:
+ try:
+ xx = np.array(x, dtype=float)
+ model = None
+ params = None
+ for i, (A, c, s, frac) in enumerate(comps, start=1):
+ pv = PseudoVoigtModel(prefix=f"p{i}_")
+ model = pv if model is None else model + pv
+ p = pv.make_params()
+ p[f"p{i}_amplitude"].set(value=max(A, 0.0), min=0.0)
+ p[f"p{i}_center"].set(value=c)
+ p[f"p{i}_sigma"].set(value=max(s, 1e-9), min=1e-12)
+ alpha_val = min(max(frac, 0.0), 1.0)
+ p[f"p{i}_fraction"].set(value=alpha_val, min=0.0, max=1.0)
+ params = p if params is None else params.update(p)
+ yy = model.eval(params=params, x=xx)
+ y_fit = yy.tolist()
+ except Exception:
+ y_fit = None
+ except Exception:
+ y_fit = None
+ return x, y, y_fit, row
+
+ # Build interactive rows
+ items = []
+ for _, r in df_sorted.iterrows():
+ idx = r.get("Index")
+ fname = r.get("File Name", "")
+ cond = r.get("Conditions", "")
+ tval = r.get("Time", "")
+ err_val = r.get("Error", np.inf)
+ note = r.get("Note", "")
+
+ label_text = f"time={tval} | cond={cond} | err={err_val:.6g} | file={fname}"
+ # Ensure readable black text (some notebook themes style tan)
+ label = widgets.HTML(value=f"{html.escape(label_text)}
")
+
+ if np.isfinite(err_val):
+ btn = widgets.Button(description="Plot", tooltip="Plot Fit vs Normalized data", layout=widgets.Layout(width="80px"))
+
+ def _make_onclick(row_index):
+ def _handler(_b=None):
+ with plot_out:
+ plot_out.clear_output()
+ x, y, y_fit, row_obj = _get_xy_and_fit(row_index)
+ if x is None or y is None or y_fit is None:
+ print("Plot unavailable: missing or invalid Fit/Normalized data for this row.")
+ # Also note in status via session summary helper
+ _emit_function_summary(
+ status_out,
+ [f"Plot unavailable for index {row_index}."],
+ title="Session Summary (Quality Check)",
+ )
+ return
+ try:
+ xx = np.asarray(x, dtype=float)
+ yy = np.asarray(y, dtype=float)
+ ff = np.asarray(y_fit, dtype=float)
+ # Align lengths if needed
+ n = min(xx.size, yy.size, ff.size)
+ xx, yy, ff = xx[:n], yy[:n], ff[:n]
+ except Exception:
+ print("Plot unavailable: data conversion error.")
+ _emit_function_summary(
+ status_out,
+ [f"Data conversion error for index {row_index}."],
+ title="Session Summary (Quality Check)",
+ )
+ return
+ # Update the current plotted index for quality controls
+ try:
+ current_plot_idx["idx"] = row_index
+ refresh_quality()
+ except Exception:
+ pass
+ fig = go.FigureWidget()
+ fig.add_scatter(x=xx, y=yy, mode="lines", name="Normalized", line=dict(color="#1f77b4"))
+ fig.add_scatter(x=xx, y=ff, mode="lines", name="Fit", line=dict(color="#d62728"))
+ try:
+ title = f"Fit vs Normalized | {row_obj.get('File Name','')} (T={row_obj.get('Time','')}, {row_obj.get('Conditions','')})"
+ except Exception:
+ title = "Fit vs Normalized"
+ fig.update_layout(title=title, xaxis_title="Wavenumber (cm⁻¹)", yaxis_title="Intensity (a.u.)", legend=dict(orientation="h"))
+ # Container: plot with "Mark spectrum as bad/good" buttons beneath
+ display(widgets.VBox([fig, widgets.HBox([mark_bad_btn, mark_good_btn])]))
+ return _handler
+
+ btn.on_click(_make_onclick(idx))
+ items.append(widgets.HBox([btn, label]))
+
+ # If there are excluded spectra, add a button to display their details
+ excluded_btn = None
+ excluded_visible = {"on": False}
+ if df_excluded is not None and not df_excluded.empty:
+ excluded_btn = widgets.Button(
+ description=f"Show excluded ({len(df_excluded)})",
+ button_style="warning",
+ tooltip="List spectra excluded due to missing/unusable fits",
+ layout=widgets.Layout(width="220px")
+ )
+
+ def _show_excluded(_b=None):
+ # Toggle: show list on first click, hide on second
+ if not excluded_visible["on"]:
+ lines = []
+ try:
+ for _, rr in df_excluded.iterrows():
+ lines.append(
+ f"idx={rr.get('Index')} | time={rr.get('Time')} | cond={rr.get('Conditions')} | note={rr.get('Note','unusable')} | file='{rr.get('File Name','')}'"
+ )
+ except Exception:
+ lines = ["Excluded spectra list unavailable."]
+ # Emit excluded list in a separate output so session summary persists
+ _emit_function_summary(
+ excluded_out,
+ lines,
+ title="Excluded Spectra (Unusable)",
+ )
+ excluded_visible["on"] = True
+ try:
+ excluded_btn.description = f"Hide excluded ({len(df_excluded)})"
+ excluded_btn.button_style = "warning"
+ except Exception:
+ pass
+ else:
+ # Hide by clearing the excluded area only (session summary persists)
+ try:
+ with excluded_out:
+ clear_output()
+ except Exception:
+ pass
+ excluded_visible["on"] = False
+ try:
+ excluded_btn.description = f"Show excluded ({len(df_excluded)})"
+ excluded_btn.button_style = "warning"
+ except Exception:
+ pass
+
+ excluded_btn.on_click(_show_excluded)
+
+ header = widgets.HTML(value=f"Material: {html.escape(str(material))} (click Plot to overlay)")
+ # Only keep the top-level Close button from check_fit_quality; no per-material Close here
+ list_children = items
+ if excluded_btn is not None:
+ list_children = [widgets.HBox([excluded_btn])] + list_children
+ list_box = widgets.VBox(list_children)
+ display(widgets.VBox([header, list_box, plot_out, status_out, excluded_out]))
+
+
+def display_DataFrame(FTIR_DataFrame, height: int = 500):
+ if FTIR_DataFrame is None or not isinstance(FTIR_DataFrame, pd.DataFrame):
+ raise ValueError("Error: FTIR_DataFrame not defined. Load or Create DataFrame first.")
+ """Display the DataFrame in a scrollable table with dropdown filters.
+
+ - Defaults to showing the entire DataFrame in a scrollable HTML table.
+ - Provides dropdowns for Material, Conditions/Condition, and Time to filter.
+
+ Parameters
+ ----------
+ FTIR_DataFrame : pd.DataFrame
+ The DataFrame to display.
+ height : int, optional
+ Height in pixels for the scrollable container (default 500).
+
+ Returns
+ -------
+ pd.DataFrame
+ The (unchanged) input DataFrame.
+ """
+ # Basic validation
+ if FTIR_DataFrame is None:
+ raise ValueError("FTIR_DataFrame must be provided.")
+
+ # Local imports for HTML display to avoid relying on module-level imports
+ try:
+ from IPython.display import display as _ip_display, HTML as _ip_HTML
+ except Exception:
+ _ip_display = None
+ _ip_HTML = None
+
+ # Determine the conditions column name (supports either 'Conditions' or 'Condition')
+ cond_col = (
+ "Conditions"
+ if "Conditions" in FTIR_DataFrame.columns
+ else ("Condition" if "Condition" in FTIR_DataFrame.columns else None)
+ )
+
+ # Helper to build dropdown options with an 'All' entry
+ def _options_for(colname):
+ try:
+ vals = (
+ FTIR_DataFrame.get(colname, None).dropna().astype(str).unique().tolist()
+ if colname in FTIR_DataFrame.columns
+ else []
+ )
+ # Unique, sorted, stringified
+ vals = sorted({str(v) for v in vals})
+ except Exception:
+ vals = []
+ return ["All"] + vals
+
+ # Special case: Time options sorted in descending numeric order (then non-numeric)
+ def _options_for_time():
+ try:
+ if "Time" not in FTIR_DataFrame.columns:
+ return ["All"]
+ ser = FTIR_DataFrame.get("Time", pd.Series([], dtype=object)).dropna()
+ # Work with string forms for stable filtering downstream
+ str_vals = list({str(v) for v in ser.astype(str).tolist()})
+
+ def _sort_key(s):
+ try:
+ num = pd.to_numeric(pd.Series([s]), errors="coerce").iloc[0]
+ except Exception:
+ num = float("nan")
+ # Numeric first (ascending), then non-numeric (ascending lexicographic)
+ if pd.isna(num):
+ return (1, s)
+ return (0, float(num))
+
+ sorted_vals = sorted(str_vals, key=_sort_key)
+ except Exception:
+ sorted_vals = []
+ return ["All"] + sorted_vals
+
+ # Build dropdowns
+ mat_dd = widgets.Dropdown(
+ options=_options_for("Material"),
+ value="All",
+ description="Material",
+ layout=widgets.Layout(width="33%"),
+ disabled=("Material" not in FTIR_DataFrame.columns),
+ )
+ cond_label = "Conditions" if cond_col != "Condition" else "Condition"
+ cond_dd = widgets.Dropdown(
+ options=_options_for(cond_col) if cond_col else ["All"],
+ value="All",
+ description=cond_label,
+ layout=widgets.Layout(width="33%"),
+ disabled=(cond_col is None),
+ )
+ time_dd = widgets.Dropdown(
+ options=_options_for_time(),
+ value="All",
+ description="Time",
+ layout=widgets.Layout(width="33%"),
+ disabled=("Time" not in FTIR_DataFrame.columns),
+ )
+ # Quality filter dropdown (canonical column name)
+ quality_dd = widgets.Dropdown(
+ options=_options_for("Quality"),
+ value="All",
+ description="Quality",
+ layout=widgets.Layout(width="33%"),
+ disabled=("Quality" not in FTIR_DataFrame.columns),
+ )
+
+ # Output area for the HTML table
+ out = widgets.Output()
+
+ # Render helper
+ def _render(*_):
+ with out:
+ out.clear_output()
+ # Compose filter mask
+ try:
+ mask = pd.Series(True, index=FTIR_DataFrame.index)
+ except Exception:
+ # Fallback: no filtering if mask creation fails
+ mask = None
+
+ # Apply Material filter
+ try:
+ if not mat_dd.disabled and mat_dd.value != "All":
+ mask = mask & (
+ FTIR_DataFrame["Material"].astype(str) == str(mat_dd.value)
+ )
+ except Exception:
+ pass
+
+ # Apply Conditions/Condition filter
+ try:
+ if cond_col and not cond_dd.disabled and cond_dd.value != "All":
+ mask = mask & (
+ FTIR_DataFrame[cond_col].astype(str) == str(cond_dd.value)
+ )
+ except Exception:
+ pass
+
+ # Apply Time filter
+ try:
+ if not time_dd.disabled and time_dd.value != "All":
+ mask = mask & (
+ FTIR_DataFrame["Time"].astype(str) == str(time_dd.value)
+ )
+ except Exception:
+ pass
+
+ # Apply Quality filter
+ try:
+ if not quality_dd.disabled and quality_dd.value != "All":
+ # Case-insensitive compare to be tolerant to stored values
+ mask = mask & (
+ FTIR_DataFrame["Quality"].astype(str).str.lower()
+ == str(quality_dd.value).lower()
+ )
+ except Exception:
+ pass
+
+ try:
+ df_view = (
+ FTIR_DataFrame[mask].copy()
+ if isinstance(mask, pd.Series)
+ else FTIR_DataFrame.copy()
+ )
+ except Exception:
+ df_view = FTIR_DataFrame.copy()
+
+ # Preserve and temporarily expand display options
+ prev_rows = pd.get_option("display.max_rows")
+ prev_cols = pd.get_option("display.max_columns")
+ try:
+ pd.set_option("display.max_rows", None)
+ pd.set_option("display.max_columns", None)
+ html = df_view.to_html(max_rows=None, max_cols=None, notebook=True)
+ finally:
+ try:
+ pd.set_option("display.max_rows", prev_rows)
+ pd.set_option("display.max_columns", prev_cols)
+ except Exception:
+ pass
+
+ if _ip_display is not None and _ip_HTML is not None:
+ _ip_display(
+ _ip_HTML(
+ f"{html}
"
+ )
+ )
+
+ # Wire up events
+ mat_dd.observe(_render, names="value")
+ cond_dd.observe(_render, names="value")
+ time_dd.observe(_render, names="value")
+ quality_dd.observe(_render, names="value")
+
+ # Action buttons
+ reset_btn = widgets.Button(
+ description="Reset Filters",
+ button_style="warning",
+ layout=widgets.Layout(width="150px"),
+ tooltip="Reset all filters to 'All'",
+ )
+ close_btn = widgets.Button(
+ description="Close",
+ button_style="danger",
+ layout=widgets.Layout(width="120px"),
+ tooltip="Close this view",
+ )
+
+ def _on_reset(_b=None):
+ # Reset dropdowns to 'All' when available and re-render
+ try:
+ if not mat_dd.disabled and "All" in mat_dd.options:
+ mat_dd.value = "All"
+ except Exception:
+ pass
+ try:
+ if not cond_dd.disabled and "All" in cond_dd.options:
+ cond_dd.value = "All"
+ except Exception:
+ pass
+ try:
+ if not time_dd.disabled and "All" in time_dd.options:
+ time_dd.value = "All"
+ except Exception:
+ pass
+ try:
+ if not quality_dd.disabled and "All" in quality_dd.options:
+ quality_dd.value = "All"
+ except Exception:
+ pass
+ # Ensure a refresh even if values were already 'All'
+ _render()
+
+ def _on_close(_b=None):
+ # Close all widgets and clear output area
+ try:
+ mat_dd.close()
+ except Exception:
+ pass
+ try:
+ cond_dd.close()
+ except Exception:
+ pass
+ try:
+ time_dd.close()
+ except Exception:
+ pass
+ try:
+ quality_dd.close()
+ except Exception:
+ pass
+ try:
+ reset_btn.close()
+ except Exception:
+ pass
+ try:
+ close_btn.close()
+ except Exception:
+ pass
+ try:
+ out.clear_output()
+ out.close()
+ except Exception:
+ pass
+ try:
+ if 'ui' in locals() or 'ui' in globals():
+ ui.close()
+ except Exception:
+ pass
+
+ reset_btn.on_click(_on_reset)
+ close_btn.on_click(_on_close)
+
+ # Layout and initial render
+ controls = widgets.HBox([mat_dd, cond_dd, time_dd, quality_dd])
+ buttons = widgets.HBox([reset_btn, close_btn])
+ ui = widgets.VBox([controls, buttons, out])
+ display(ui)
+ _render()
+
+ return FTIR_DataFrame
+
+
+def export_material_output_csv(
+ FTIR_DataFrame,
+ material: str,
+ *,
+ materials_json_path: str | None = None,
+ output_path: str | None = None,
+):
+ """Export a material-specific CSV with standardized columns and peak headers.
+
+ Filename: material_output_.csv (unless output_path is provided)
+
+ Columns (in order):
+ - Name, Alias, Condition, Sample Humidity, Sample Temperature, Time, Normalization Peak, Quality
+ - Followed by one column per peak with header:
+ 'Peak _name=""_sigma=<σ>,alpha=<α>' (values from materials.json)
+
+ Notes
+ -----
+ - Populates one CSV row per DataFrame row for the selected material.
+ - Peak columns are populated from 'Material Fit Results' amplitudes; blanks when
+ amplitudes are missing or unusable.
+ - Uses the DataFrame's 'Normalization Peak Wavenumber' for the 'Normalization Peak'
+ column as-is (string or numeric). Quality is taken from the detected quality column.
+ """
+ if FTIR_DataFrame is None or not isinstance(FTIR_DataFrame, pd.DataFrame):
+ raise ValueError("Error: FTIR_DataFrame not defined. Load or Create DataFrame first.")
+ if material is None or str(material).strip() == "":
+ raise ValueError("'material' must be a non-empty string.")
+
+ import os, json
+
+ # Resolve materials.json path (default: alongside this module)
+ if materials_json_path is None:
+ try:
+ materials_json_path = os.path.join(os.path.dirname(__file__), "materials.json")
+ except Exception:
+ materials_json_path = "materials.json"
+
+ # Load materials.json
+ try:
+ with open(materials_json_path, "r", encoding="utf-8") as f:
+ _content = json.load(f)
+ except Exception as e:
+ raise FileNotFoundError(f"Could not load materials.json at {materials_json_path!r}: {e}")
+
+ # Top-level structure is a list with one dict of material codes
+ if not isinstance(_content, list) or not _content or not isinstance(_content[0], dict):
+ raise ValueError("materials.json unexpected structure; expected a list with a single mapping object")
+ _top = _content[0]
+
+ # Find material entry by name or alias
+ mat_code = None
+ mat_payload = None
+ target_name = str(material)
+ try:
+ for k, v in _top.items():
+ if not isinstance(v, dict):
+ continue
+ if str(v.get("alias", "")) == target_name or str(v.get("name", "")) == target_name:
+ mat_code = k
+ mat_payload = v
+ break
+ except Exception:
+ pass
+ if mat_code is None or not isinstance(mat_payload, dict):
+ raise KeyError(f"Material {material!r} not found in materials.json (by 'name' or 'alias').")
+
+ mat_name = str(mat_payload.get("name", material))
+ mat_alias = str(mat_payload.get("alias", material))
+ peaks_def = mat_payload.get("peaks", {}) or {}
+
+ # Build peak column headers from JSON (sorted by numeric key order)
+ def _peak_header(idx_key: str):
+ p = peaks_def.get(idx_key, {}) or {}
+ pname = str(p.get("name", ""))
+ # Extract numeric center; support both 'center_wavenumber' and 'center' keys
+ pcenter = None
+ for key in ("center_wavenumber", "center"):
+ try:
+ val = p.get(key, None)
+ if val is not None:
+ pcenter = float(val)
+ break
+ except Exception:
+ pass
+ if pcenter is None:
+ pcenter = 0.0
+ try:
+ psigma = float(p.get("σ", 0))
+ except Exception:
+ psigma = 0.0
+ try:
+ palpha = float(p.get("α", 0))
+ except Exception:
+ palpha = 0.0
+ # Title format: Peak 1_name=""_center=#,sigma=#,alpha=#
+ return f"Peak{idx_key}_name={pname}_center={pcenter},sigma={psigma},alpha={palpha}"
+
+ peak_keys_sorted = sorted(peaks_def.keys(), key=lambda s: int(str(s)) if str(s).isdigit() else str(s))
+ peak_headers = [_peak_header(k) for k in peak_keys_sorted]
+
+ # Determine columns from DataFrame
+ cond_col = _conditions_column_name(FTIR_DataFrame)
+ q_col = _quality_column_name(FTIR_DataFrame)
+ norm_col = "Normalization Peak Wavenumber"
+
+ # Filter rows for selected material (exact match on 'Material')
+ try:
+ df_mat = FTIR_DataFrame[FTIR_DataFrame.get("Material").astype(str) == str(material)]
+ except Exception:
+ df_mat = FTIR_DataFrame.iloc[0:0]
+
+ # Sort rows by Time (if present)
+ try:
+ if "Time" in df_mat.columns:
+ df_mat = df_mat.copy()
+ df_mat["_sort_time"] = pd.to_numeric(df_mat["Time"], errors="coerce").fillna(float("inf"))
+ df_mat = df_mat.sort_values(by=["_sort_time"], kind="mergesort")
+ df_mat.drop(columns=["_sort_time"], inplace=True, errors="ignore")
+ except Exception:
+ pass
+
+ # Base columns
+ base_headers = [
+ "Name",
+ "Alias",
+ "Condition",
+ "Sample Humidity",
+ "Sample Temperature",
+ "Time",
+ "Normalization Peak",
+ "Quality",
+ ]
+ export_headers = base_headers + peak_headers
+
+ # Helper: extract amplitudes list from a 'Material Fit Results' cell
+ def _amps_from_fit_cell(cell):
+ try:
+ v = _safe_literal_eval(cell, value_name="Material Fit Results")
+ except Exception:
+ v = cell
+ # Direct list of numbers (preferred modern format)
+ if isinstance(v, (list, tuple)):
+ try:
+ return [float(x) for x in v]
+ except Exception:
+ return None
+ # Dict-based legacy formats
+ if isinstance(v, dict):
+ for key in ("amplitudes", "amps", "areas", "A"):
+ if key in v and isinstance(v[key], (list, tuple)):
+ try:
+ return [float(x) for x in v[key]]
+ except Exception:
+ return None
+ # Sometimes stored as list of peak dicts under 'peaks'
+ if isinstance(v.get("peaks"), (list, tuple)):
+ vals = []
+ for p in v.get("peaks", []):
+ if isinstance(p, dict):
+ a = p.get("amplitude", p.get("amp", p.get("area")))
+ try:
+ vals.append(float(a))
+ except Exception:
+ vals.append(None)
+ return vals if vals else None
+ return None
+
+ # Assemble rows (populate peak columns from amplitudes where available)
+ rows = []
+ for _, r in df_mat.iterrows():
+ try:
+ row_vals = [
+ mat_name,
+ mat_alias,
+ (r.get(cond_col) if cond_col else None),
+ r.get("Sample Humidity"),
+ r.get("Sample Temperature"),
+ r.get("Time"),
+ r.get(norm_col),
+ r.get(q_col),
+ ]
+ # Extract amplitudes for peaks
+ amps = _amps_from_fit_cell(r.get("Material Fit Results"))
+ fname = r.get("File Name", "")
+ # Only populate when counts match; otherwise leave blank and report
+ if isinstance(amps, list) and len(amps) == len(peak_headers):
+ row_vals.extend(amps)
+ else:
+ row_vals.extend([None] * len(peak_headers))
+ try:
+ if isinstance(amps, list):
+ print(
+ f"export_material_output_csv: amplitude count {len(amps)} != peak count {len(peak_headers)} for file '{fname}'; leaving peak columns blank."
+ )
+ else:
+ print(
+ f"export_material_output_csv: missing/unreadable amplitudes in 'Material Fit Results' for file '{fname}'; leaving peak columns blank."
+ )
+ except Exception:
+ pass
+ except Exception:
+ # On any failure, append a minimal-length row padded with None
+ row_vals = [mat_name, mat_alias, None, None, None, None, None, None] + [None] * len(peak_headers)
+ rows.append(row_vals)
+
+ # Build DataFrame and write CSV
+ out_df = pd.DataFrame(rows, columns=export_headers)
+ # Default output: CWD/material_output_.csv
+ if output_path is None:
+ safe_mat = str(material).replace("/", "-").replace("\\", "-")
+ output_path = os.path.join(os.getcwd(), f"material_output_{safe_mat}.csv")
+ try:
+ out_df.to_csv(output_path, index=False)
+ print(f"Exported material CSV: {output_path}")
+ except Exception as e:
+ raise IOError(f"Failed to write CSV to {output_path!r}: {e}")
+ return output_path
+
+
+def trim_DataFrame(FTIR_DataFrame):
+ """Interactively clear selected columns in `FTIR_DataFrame`.
+
+ UI features:
+ - Filter mode: select `Material`, `Conditions`, and `Time`, with an option to include bad spectra.
+ - Index mode: toggle to target a single row index directly.
+ - Column checklist: choose which columns to clear for the targeted rows.
+ - Apply clears selected columns, Close hides the UI but keeps a session summary visible.
+
+ Returns the updated DataFrame.
+ """
+
+ if FTIR_DataFrame is None or not isinstance(FTIR_DataFrame, pd.DataFrame):
+ raise ValueError("trim_DataFrame: FTIR_DataFrame must be a valid pandas DataFrame")
+
+ # Session tracking for summary output
+ session_lines = []
+ session_changes = {}
+
+ # Ensure common columns exist gracefully
+ _require_columns(
+ FTIR_DataFrame,
+ [
+ "File Name",
+ "Material",
+ "Conditions",
+ "Time",
+ ],
+ context="FTIR_DataFrame (trim_DataFrame)",
+ )
+
+ # Persisted defaults across tools
+ defaults = _get_session_defaults()
+
+ # Materials and Conditions lists
+ materials, conditions = _extract_material_condition_lists(FTIR_DataFrame, exclude_unexposed=False) or ([], [])
+ materials = sorted(materials)
+ conditions = sorted(conditions)
+
+ # Time list
+ try:
+ times_unique = sorted([t for t in FTIR_DataFrame["Time"].dropna().unique()])
+ except Exception:
+ times_unique = []
+
+ # Safe import for display/clear_output (avoid re-importing widgets)
+ try:
+ from IPython.display import display, clear_output # type: ignore
+ except Exception:
+ display = None # type: ignore
+ clear_output = None # type: ignore
+
+ # Widgets
+ use_index_toggle = widgets.ToggleButton(
+ value=False,
+ description="Use index instead",
+ layout=widgets.Layout(width="200px", margin="0 0 10px 0"),
+ button_style="warning",
+ )
+ index_input = widgets.IntText(
+ value=int(FTIR_DataFrame.index[0]) if len(FTIR_DataFrame.index) > 0 else 0,
+ description="Index",
+ layout=widgets.Layout(width="220px"),
+ )
+
+ material_dd = widgets.Dropdown(
+ options=["any"] + materials,
+ value=(defaults.get("material") if defaults.get("material") in materials else "any"),
+ description="Material",
+ layout=widgets.Layout(width="40%"),
+ )
+ conditions_dd = widgets.Dropdown(
+ options=["any"] + conditions,
+ value=(defaults.get("conditions") if defaults.get("conditions") in conditions else "any"),
+ description="Conditions",
+ layout=widgets.Layout(width="40%"),
+ )
+ time_dd = widgets.Dropdown(
+ options=["any"] + times_unique,
+ value=(defaults.get("time") if defaults.get("time") in times_unique else "any"),
+ description="Time",
+ layout=widgets.Layout(width="25%"),
+ )
+ include_bad_cb = widgets.Checkbox(value=False, description="Include bad spectra")
+
+ # Column checklist: list all columns except core identifiers
+ identifier_cols = {"File Location", "File Name", "Material", "Conditions", "Time"}
+ col_options = [c for c in FTIR_DataFrame.columns if c not in identifier_cols]
+ col_checks = [widgets.Checkbox(value=False, description=c) for c in col_options]
+ # Make the list scrollable
+ col_box = widgets.VBox(col_checks, layout=widgets.Layout(max_height="250px", overflow_y="auto", border="1px solid #ddd", padding="6px"))
+
+ apply_btn = widgets.Button(description="Apply", button_style="success")
+ close_btn = widgets.Button(description="Close", button_style="danger")
+
+ msg_out = widgets.Output()
+ # Persistent status area that remains visible after Close
+ top_status_out = widgets.Output()
+ # Session tracking for summary output
+ session_lines = []
+ session_changes = {}
+
+ # Dynamic containers for filter vs index-only mode
+ filter_row = widgets.HBox([material_dd, conditions_dd, time_dd, include_bad_cb])
+ index_row = widgets.HBox([index_input])
+ # Start in filter mode
+ index_row.layout.display = "none"
+
+ # Layout
+ controls_top = widgets.HBox([use_index_toggle])
+ controls = widgets.VBox([controls_top, filter_row, index_row])
+ actions = widgets.HBox([apply_btn, close_btn])
+ ui = widgets.VBox([controls, col_box, actions, msg_out])
+
+ # Seed initial instruction in persistent area
+ try:
+ _emit_function_summary(
+ top_status_out,
+ [
+ "Select filters or toggle to Index mode.",
+ "Check columns to clear, then click Apply.",
+ "Click Close to view session summary.",
+ ],
+ title="Trim DataFrame",
+ )
+ except Exception:
+ pass
+
+ if display is not None:
+ display(ui, top_status_out)
+ else:
+ # Fallback: at least show UI; summary will print on close via msg_out
+ try:
+ print("Trim DataFrame UI loaded. Close to see summary.")
+ except Exception:
+ pass
+
+ # Helper: build mask based on mode
+ def _mask_for_selection():
+ if use_index_toggle.value:
+ # Index-only mode
+ idx = index_input.value
+ mask = FTIR_DataFrame.index == idx
+ return mask
+ # Filter mode
+ mask = pd.Series([True] * len(FTIR_DataFrame), index=FTIR_DataFrame.index)
+ mat = material_dd.value
+ cond = conditions_dd.value
+ tim = time_dd.value
+ if isinstance(mat, str) and mat.strip().lower() != "any":
+ mask &= FTIR_DataFrame["Material"].astype(str).str.lower() == mat.strip().lower()
+ if isinstance(cond, str) and cond.strip().lower() != "any":
+ # Use detected conditions column name
+ cond_col = _conditions_column_name(FTIR_DataFrame) or "Conditions"
+ mask &= FTIR_DataFrame[cond_col].astype(str).str.lower() == cond.strip().lower()
+ if tim != "any":
+ try:
+ mask &= FTIR_DataFrame["Time"] == tim
+ except Exception:
+ pass
+ if not include_bad_cb.value:
+ try:
+ mask &= _quality_good_mask(FTIR_DataFrame)
+ except Exception:
+ pass
+ return mask
+
+ # Toggle behavior
+ def _on_toggle(change):
+ if use_index_toggle.value:
+ use_index_toggle.description = "Use filters instead"
+ use_index_toggle.button_style = "info"
+ filter_row.layout.display = "none"
+ index_row.layout.display = ""
+ else:
+ use_index_toggle.description = "Use index instead"
+ use_index_toggle.button_style = "warning"
+ filter_row.layout.display = ""
+ index_row.layout.display = "none"
+
+ use_index_toggle.observe(_on_toggle, names="value")
+
+ # Apply
+ def _on_apply(_b=None):
+ selected_cols = [cb.description for cb in col_checks if cb.value]
+ with msg_out:
+ msg_out.clear_output()
+ if not selected_cols:
+ print("No columns selected; nothing to clear.")
+ return
+ mask = _mask_for_selection()
+ rows = FTIR_DataFrame[mask]
+ if rows.empty:
+ print("No rows match the current selection; nothing to clear.")
+ return
+ # Perform clearing: set cells to NaN
+ FTIR_DataFrame.loc[mask, selected_cols] = np.nan
+
+ # Persist session defaults when using filters
+ if not use_index_toggle.value:
+ _set_session_selection(material=material_dd.value, conditions=conditions_dd.value, time=(time_dd.value if time_dd.value != "any" else "any"))
+
+ # Summary
+ session_changes.setdefault("trim", []).append((len(rows), selected_cols))
+ session_lines.append(
+ f"Cleared {len(rows)} row(s) in columns: {', '.join(selected_cols)}"
+ )
+ try:
+ _emit_function_summary(top_status_out, session_lines, title="Session Summary")
+ except Exception:
+ for line in session_lines:
+ print(line)
+
+ apply_btn.on_click(_on_apply)
+
+ # Close: hide UI but keep summary visible
+ def _on_close(_b=None):
+ # Hide interactive elements
+ try:
+ ui.layout.display = "none"
+ except Exception:
+ pass
+ # Replace persistent area content with a consolidated session summary
+ try:
+ if clear_output is not None:
+ with top_status_out:
+ clear_output()
+ except Exception:
+ pass
+ with top_status_out:
+ try:
+ if session_lines:
+ _emit_function_summary(top_status_out, session_lines, title="Session Summary")
+ except Exception:
+ # Fallback to printing accumulated lines
+ for line in session_lines:
+ print(line)
+
+ close_btn.on_click(_on_close)
+
+ return FTIR_DataFrame
diff --git a/tutorials/tools/Tools - FTIR Analysis.ipynb b/tutorials/tools/Tools - FTIR Analysis.ipynb
new file mode 100644
index 00000000..a274e0ea
--- /dev/null
+++ b/tutorials/tools/Tools - FTIR Analysis.ipynb
@@ -0,0 +1,887 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "ffae5f63",
+ "metadata": {},
+ "source": [
+ "# FTIR Data Analysis Main Workflow\n",
+ " Author: Trenton Wells\n",
+ "\n",
+ " Created: Sept 2025\n",
+ "\n",
+ " Organization: National Lab of the Rockies\n",
+ "\n",
+ " Personal Contact: trentonwells73@gmail.com\n",
+ "\n",
+ "This notebook guides you through the main steps of the FTIR data analysis workflow.\n",
+ "\n",
+ "On repeated running of the notebook, the only necessary setup should be the imports and loading the DataFrame, after which you can pick up where you left off. Remember to Save your work at the bottom of the Notebook before closing or restarting.\n",
+ "\n",
+ "NOTE: having multiple interactive cells open simultaneously can take up a lot of working memory, so click 'close' when done with one to minimize memory load."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "baac3563",
+ "metadata": {},
+ "source": [
+ "## 1) Setup"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "853555d0",
+ "metadata": {},
+ "source": [
+ "### Import Functions"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "57ace244",
+ "metadata": {},
+ "source": [
+ "Import necessary functions for data analysis and visualization."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "58e5b728",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from Analysis_FTIR import (\n",
+ " rename_files,\n",
+ " extract_file_info,\n",
+ " display_DataFrame,\n",
+ " trim_DataFrame,\n",
+ " populate_material_dictionary,\n",
+ " plot_spectra,\n",
+ " baseline_correct_spectra,\n",
+ " bring_in_DataFrame,\n",
+ " normalize_spectra,\n",
+ " find_peak_info,\n",
+ " deconvolute_peaks,\n",
+ " fit_material,\n",
+ " check_fit_quality,\n",
+ " export_material_output_csv,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c55543b1",
+ "metadata": {},
+ "source": [
+ "### Load or Create DataFrame"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0caad844",
+ "metadata": {},
+ "source": [
+ "The DataFrame stores all of the relevant information on the spectra in an organized format. Processes within this Notebook often refer to the DataFrame within the working memory, and it is saved at the end of the Notebook. If running this for the first time, this cell creates a blank DataFrame that will be filled in by the next cell."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "d5ef5b29",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Set path to your DataFrame CSV file. Leave as None if DataFrame is new or in default \n",
+ "# location.\n",
+ "DataFrame_path = None\n",
+ "\n",
+ "FTIR_DataFrame, DataFrame_path = bring_in_DataFrame(DataFrame_path=DataFrame_path)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a69f49c6",
+ "metadata": {},
+ "source": [
+ "### Rename Files (optional)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ad1ee19f",
+ "metadata": {},
+ "source": [
+ "You can optionally rename files in your dataset.\n",
+ "\n",
+ "This script scans a specified root directory and its subdirectories to find and rename files. Folder names will not be changed,except in the case of date renaming to ISO format (e.g., 2025-09-18) (optional). It works by replacing spaces and/or specified words in the filenames. (e.g., replacing spaces with underscores). Suggested to use this tool if file names have inconsistent naming conventions that may cause issues in downstream processing.\n",
+ "\n",
+ "NOTE: Spectra from samples which have not undergone degradation should be labelled \"unexposed\". All other conditions can be named according to user preference."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "c80c6551",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Set directory to rename folders and files within (e.g., r\"C:\\Users\\user1\\folder1\").\n",
+ "directory = r\"C:\\Users\\user1\\folder1\"\n",
+ "\n",
+ "# If you want to replace spaces in filenames, set replace_spaces to True and set \n",
+ "# character_to_use to the desired separator (e.g., \"_\").\n",
+ "replace_spaces = False\n",
+ "character_to_use = \"_\"\n",
+ "\n",
+ "# If you want to convert all dates in the directory names to ISO format (YYYY-MM-DD), \n",
+ "# set iso_date_rename to True\n",
+ "iso_date_rename = False\n",
+ "\n",
+ "# If you want to replace other specified words in filenames, set file_rename to True and\n",
+ "# provide pairs_input (e.g., \"old1:new1,old2:new2\").\n",
+ "file_rename = False\n",
+ "pairs_input = \"old1:new1,old2:new2\"\n",
+ "\n",
+ "# Set dry_run to True to preview changes without renaming files.\n",
+ "dry_run = False\n",
+ "\n",
+ "# Rename files in the specified directory.\n",
+ "rename_files(\n",
+ " directory=directory,\n",
+ " replace_spaces=replace_spaces,\n",
+ " character_to_use=character_to_use,\n",
+ " iso_date_rename=iso_date_rename,\n",
+ " file_rename=file_rename,\n",
+ " pairs_input=pairs_input,\n",
+ " dry_run=dry_run\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ad02311b",
+ "metadata": {},
+ "source": [
+ "### Fill or Append Spectra to DataFrame"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d55efc92",
+ "metadata": {},
+ "source": [
+ "Gathers file information and builds the main data structure for analysis. Repeated uses can append new data into the existing DataFrame.\n",
+ "\n",
+ "The DataFrame will have a row for each spectrum file, with columns as follows:\n",
+ "\n",
+ "File Location, File Name, Date, Conditions, Material, Time, X-Axis, Raw Data, Baseline Function, Baseline Parameters, Baseline, Baseline-Corrected Data, Normalization Peak Wavenumber, Normalized and Corrected Data\n",
+ "\n",
+ "This function will append any files that aren't already included.\n",
+ "If FTIR_DataFrame is empty it will create it from scratch.\n",
+ "\n",
+ "NOTE: ensure that spectra for samples which have not undergone degradation are labelled as \"unexposed\" for their condition term."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f162543f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Set directory containing files to analyze (e.g., r\"C:\\Users\\user1\\folder1\").\n",
+ "directory = r\"Y:\\5200\\Packaging Reliability\\Durability Tool\\Ray Tracing and Activation Spectrum\\ATR-FTIR Data\"\n",
+ "# Set file types to include (e.g., [\".dpt\", \".txt\", \".csv\"]).\n",
+ "file_types = \".dpt\"\n",
+ "# Set separators to use when finding terms within filenames (e.g., [\"_\", \" \"])\n",
+ "separators = \"_\"\n",
+ "# Set material terms to search for in filenames (e.g., [\"Si\", \"Perovskite\", \"Glass\"]) \n",
+ "# (case-insensitive).\n",
+ "material_terms = \"CPC, t-PVDF, t-PVF, o-PVF, PPE, J-BOX#1, J-BOX#2, PO, PMMA\"\n",
+ "# Set exposure conditions terms to search for in filenames (e.g., [\"A3\", \"A4\", \"B3\", \"B4\", \"unexposed\"])\n",
+ "# (case-insensitive). Make sure to include 'unexposed' for control samples.\n",
+ "conditions_terms = \"A3, A4, A5, 0.5X, 1X, 2.5X, 5X, ARC, OPN, KKCE, unexposed\"\n",
+ "# append_missing controls the addition of files if some of the metadata information is missing. \n",
+ "# True to add files even if some information is missing (may lead to issues downstream)\n",
+ "# False to skip files with missing information.\n",
+ "append_missing = False\n",
+ "# Set track_replicates to True to print the groups of replicate files\n",
+ "track_replicates = False\n",
+ "# Set access_subdirectories to False if you only want to search within folders in the\n",
+ "# specified directory that have dates as their names. This lets you avoid searching\n",
+ "# through unrelated folders that happen to be in the same directory.\n",
+ "access_subdirectories = False\n",
+ "# If any of these parameters are set to None or not specified, you will be prompted for input (may result\n",
+ "# in multiple prompts and/or minor formatting issues).\n",
+ "\n",
+ "# Extract File Information and build or append to the main DataFrame.\n",
+ "FTIR_DataFrame = extract_file_info(\n",
+ " FTIR_DataFrame=FTIR_DataFrame,\n",
+ " directory=directory,\n",
+ " file_types=file_types,\n",
+ " separators=separators,\n",
+ " material_terms=material_terms,\n",
+ " conditions_terms=conditions_terms,\n",
+ " append_missing=append_missing,\n",
+ " access_subdirectories=access_subdirectories,\n",
+ " track_replicates=track_replicates,\n",
+ ")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d681947e",
+ "metadata": {},
+ "source": [
+ "### Open the Peak Information Dictionary"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b063965b",
+ "metadata": {},
+ "source": [
+ "Loads materials.json using the DataFrame as a reference for material names/aliases. This will be used for describing the peaks for each material."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "4c7599de",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "materials_json_path = None # looks for materials.json in the active directory if None\n",
+ "populate_material_dictionary(FTIR_DataFrame, materials_json_path=materials_json_path)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1c1ebbd8",
+ "metadata": {},
+ "source": [
+ "### Display DataFrame (optional)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "62a19bbb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "FTIR_DataFrame = display_DataFrame(FTIR_DataFrame, height=500)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "049ce0ef",
+ "metadata": {},
+ "source": [
+ "### Trim DataFrame (optional)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8c214b18",
+ "metadata": {},
+ "source": [
+ "Allows for the deletion of data from the DataFrame. Uses filtering options or exact index inputs for flexible use. \n",
+ "\n",
+ "If the index is set, then the trim will apply to only that index.\n",
+ "\n",
+ "It is suggested that you use the 'Save Progress' cell at the end of the Notebook before doing this, so that unintended deletions are impermanent."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "85d74a20",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "15f24f769a944633906f3caffeb395ca",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "VBox(children=(VBox(children=(HBox(children=(ToggleButton(value=False, button_style='warning', description='Us…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "cd6eddabbf4a411f92a8c9ddf3608707",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Output()"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "FTIR_DataFrame = trim_DataFrame(FTIR_DataFrame)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e21d25f0",
+ "metadata": {},
+ "source": [
+ "### Plot Spectra (optional)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "3e0d7d11",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "plot_spectra(FTIR_DataFrame=FTIR_DataFrame)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "254fcae0",
+ "metadata": {},
+ "source": [
+ "## 2) Baseline Correction"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b70d7422",
+ "metadata": {},
+ "source": [
+ "You can choose a baseline approximation function for each different material that you have data for. It's recommended that you use 'ARPLS' with tweaked parameters or use 'Manual'. However, some datasets work better with different methods, so experiment if necessary.\n",
+ "\n",
+ "Baseline Options:\n",
+ "\n",
+ "Asymmetric Least Square \n",
+ "\n",
+ " 'ARPLS': asymmetrically reweighted penalized least squares smoothing-- an asymmetric least square method that uses a weighting function to account for noisy data.\n",
+ "\n",
+ "Spline\n",
+ "\n",
+ " 'IRSQR': iterative reweighted spline quantile regression-- uses penalized splines and iterative reweighted least squares to perform quantile regression.\n",
+ "\n",
+ "Classification\n",
+ "\n",
+ " 'FABC': fully automatic baseline correction-- uses first derivative approximation of data to identify and then ignore peak regions, then fits to baseline regions using Whittaker smoothing.\n",
+ "\n",
+ "Manual\n",
+ "\n",
+ " 'Manual': set \"anchor points\" for each of your materials using the built-in tool. This will create a list of wavenumber values that should be chosen due to always falling in the baseline regions for each spectrum of that material. A cubic spline interpolation will be done between those points' values in each scan.\n",
+ "\n",
+ "Accepts a filepath as an argument if you want to experiment with a specific file.\n",
+ "\n",
+ "Close when complete."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "08671e15",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "filepath = None # If None, will let user pick spectrum to visualize. If specified, \n",
+ "# provide the full file path string with r\"\" (e.g., r\"C:\\\\path\\\\to\\\\file.dpt\").\n",
+ "FTIR_DataFrame = baseline_correct_spectra(FTIR_DataFrame, filepath=filepath)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "08e6e58c",
+ "metadata": {},
+ "source": [
+ "## 3) Normalization"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4398199c",
+ "metadata": {},
+ "source": [
+ "Select a peak for each material that does not change shape with time (aka does not degrade). Each spectrum of that material will be scaled so that the normalization peak is the same amplitude in each, giving a normalized set of spectra that can be more accurately compared to each other.\n",
+ "\n",
+ "Click on either side of the selected normalization peak, so that the tip of the peak appears within that range for every spectrum of the selected material."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a495f57e",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "filepath = None # If None, will let user pick spectrum to visualize. If specified, \n",
+ "# provide the full file path string with r\"\" (e.g., r\"C:\\\\path\\\\to\\\\file.dpt\").\n",
+ "FTIR_DataFrame = normalize_spectra(\n",
+ " FTIR_DataFrame, filepath=filepath\n",
+ " )"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "88f04e6b",
+ "metadata": {},
+ "source": [
+ "## 4) Deconvolution"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "07bb4936",
+ "metadata": {},
+ "source": [
+ "### Peak-Finding"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "78afca46",
+ "metadata": {},
+ "source": [
+ "Gives a starting point from which to refine the peaks list for each material. The next step allows for manual peak addition, deletion, and modification.\n",
+ "\n",
+ "Utilize range 2 and range 3 within the interactive tool in order to specify multiple peak regions.\n",
+ "\n",
+ "Close when complete."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "efd9b617",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "28c2cb4041384ece9bf71cbd5e738476",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(Dropdown(description='Material', layout=Layout(width='40%'), options=('any', 'CPC', 'J-BOX#1', …"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "74680484af3142888bffe85a5102d041",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(Dropdown(description='Spectrum', layout=Layout(width='70%'), options=(('PPE | unexposed | T=0 |…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "d1e86a3dce70437a885db8de80a4ca8d",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(Checkbox(value=True, description='Use range 1'), FloatRangeSlider(value=(399.64138, 3998.47381)…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "e48eed4f45e84642a4c1dcc60eaa8ef7",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(Checkbox(value=False, description='Use range 2'), FloatRangeSlider(value=(399.64138, 3998.47381…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "871822dea8cf42debb89ed7c761e5442",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(Checkbox(value=False, description='Use range 3'), FloatRangeSlider(value=(399.64138, 3998.47381…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "e3f2a2c0ff39448daab00bd658b3b73b",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(FloatSlider(value=0.05, continuous_update=False, description='Prominence', max=1.0, readout_for…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "7686348a7cc648bfb4e4f132a37dace7",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "VBox(children=(FigureWidget({\n",
+ " 'data': [{'mode': 'lines',\n",
+ " 'name': 'Normalized and Corrected',…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "bbb87f964a6d4f52bb5affd64318e00e",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(IntSlider(value=1, continuous_update=False, description='Min width', max=50, min=1, style=Slide…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "1004ffd7af924029b5bf66564787710e",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(Button(button_style='success', description='Save for spectrum', style=ButtonStyle()), Button(bu…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "345d71dbf9fc4ac4bd2c0d5aa050044e",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Output()"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "filepath = None # If None, will let user pick spectrum to visualize. If specified, \n",
+ "# provide the full file path string with r\"\" (e.g., r\"C:\\\\path\\\\to\\\\file.dpt\").\n",
+ "FTIR_DataFrame = find_peak_info(FTIR_DataFrame, filepath=filepath)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0235d9ae",
+ "metadata": {},
+ "source": [
+ "### Deconvolution"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ad878133",
+ "metadata": {},
+ "source": [
+ "To process all spectra of a material quickly, get all of the peaks included that you want for a material and click \"Canonize Peaks\", which will save that list of peaks. To use that canon list of peaks, you click \"Load Canon Peaks\" after selecting a spectrum to change the displayed peak list to the canon one.\n",
+ "\n",
+ "If a peak should be steeper (go towards zero faster as it leaves its center point), then decrease that peak's α value. If a peak should be wider, do the opposite. The \"Reduced chi-square\" value is a scaled version of Sum Squared Error between the model and the data, accounting for differences in X-Range and number of included peaks; but visual tests are also useful for the purpose of error estimation.\n",
+ "\n",
+ "Offers automated optimization of the alpha parameter, though the time this takes scales quickly with the number of peaks being optimized. This is best used for a small area or for when you can step away and let the program run on its own.\n",
+ "\n",
+ " Fastest Method: Finalize peak locations for one spectrum of a material and canonize those peaks. Select the region of interest, run a fit, optimize the alpha values, and save the results for the spectrum. Then switch to a new spectrum, load the canon peaks, fit, optimize the alpha values, and save the results. Repeat until all spectra of the material are deconvoluted. Slow down at any step to tweak peak parameters, if desired.\n",
+ "\n",
+ "Close when complete."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "5296e0a6",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "1b4f470286c44d1b9db8a980c1ef6fc2",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "VBox(children=(HBox(children=(Dropdown(description='Material', layout=Layout(width='40%'), options=('any', 'PP…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "a7a1cd50d0bd44b0ac8d4b40632b5850",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HTML(value='')"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "filepath = None # If not None, will only analyze specified file's DataFrame entry\n",
+ "FTIR_DataFrame = deconvolute_peaks(FTIR_DataFrame, filepath=filepath)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "98037cf1",
+ "metadata": {},
+ "source": [
+ "## 5) Model Fitting"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "4348633e",
+ "metadata": {},
+ "source": [
+ "### Material Fitting\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "64c8b685",
+ "metadata": {},
+ "source": [
+ "Fitting takes the found peak parameters for every deconvoluted spectrum of the selected material and averages them to create material-wide accepted values, then runs another PseudoVoigt fit to obtain new amplitudes with those averaged parameters.\n",
+ "\n",
+ "Optimization will iteratively modify select parameters to minimize the error across the materials' spectra.\n",
+ "\n",
+ "Saving will put peak parameters into materials.json and peak areas into the DataFrame.\n",
+ "\n",
+ "Close when complete."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "12819640",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "5d78677dced14f42897a1a190a214b20",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "VBox(children=(HBox(children=(Dropdown(description='Material', layout=Layout(width='40%'), options=('PPE',), v…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "bb3ab7a953074ae88d664b40b2bf2e0b",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HTML(value=\"Run 'Fit Material' to populate the peak parameters table.\")"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "28dee9ffe77c4669b22c3797d5e6e42e",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HTML(value=\"Run 'Fit Material' to populate the peak areas table.\")"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "FTIR_DataFrame = fit_material(FTIR_DataFrame)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cb4fe6d4",
+ "metadata": {},
+ "source": [
+ "### Quality Check"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "946fc0c8",
+ "metadata": {},
+ "source": [
+ "Shows which spectra have the greatest error between the Fit and their Normalized dataset, and plots them for easy issue identification."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "114f35d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "FTIR_DataFrame = check_fit_quality(FTIR_DataFrame)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ec094ead",
+ "metadata": {},
+ "source": [
+ "## 6) Results"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "a442faab",
+ "metadata": {},
+ "source": [
+ "### Output to .CSV"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "a9bd477b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Export a material-specific CSV\n",
+ "\n",
+ "# Set the material alias exactly as it appears in your DataFrame/materials.json\n",
+ "material = \"PPE\"\n",
+ "\n",
+ "# Optional: customize paths\n",
+ "# materials_json_path = \"materials.json\" # default resolves next to Analysis_FTIR.py\n",
+ "# output_path = r\"material_output_*alias*.csv\" # set a custom path if desired\n",
+ "\n",
+ "# Run export (defaults used if optional args are omitted)\n",
+ "csv_path = export_material_output_csv(\n",
+ " FTIR_DataFrame,\n",
+ " material,\n",
+ " # materials_json_path=materials_json_path,\n",
+ " # output_path=output_path,\n",
+ ")\n",
+ "print(f\"Exported CSV: {csv_path}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "69dd0cec",
+ "metadata": {},
+ "source": [
+ "### Save Progress"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "a2436844",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "DataFrame saved to FTIR_DataFrame.csv\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Save the entire DataFrame to CSV\n",
+ "DataFrame_path = DataFrame_path # Specify the path to your DataFrame CSV file (default \n",
+ "# will be FTIR_DataFrame.csv in the active directory)\n",
+ "FTIR_DataFrame.to_csv(DataFrame_path, index=False)\n",
+ "print(f\"DataFrame saved to {DataFrame_path}\")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "FTIR-SCAN",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.13.7"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}