batplot 1.8.34__tar.gz → 1.8.36__tar.gz

{batplot-1.8.34/batplot.egg-info → batplot-1.8.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: batplot
-Version: 1.8.34
+Version: 1.8.36
 Summary: Interactive plotting tool for material science (1D plot) and electrochemistry (GC, CV, dQ/dV, CPC, operando) with batch processing
 Author-email: Tian Dai <tianda@uio.no>
 License: MIT License

{batplot-1.8.34 → batplot-1.8.36}/batplot/__init__.py

@@ -1,5 +1,5 @@
 """batplot: Interactive plotting for battery data visualization."""
 
-__version__ = "1.8.34"
+__version__ = "1.8.36"
 
 __all__ = ["__version__"]

{batplot-1.8.34 → batplot-1.8.36}/batplot/batplot.py

@@ -23,7 +23,17 @@ from .session import (
 )
 from .operando import plot_operando_folder
 from .plotting import update_labels
-from .utils import _confirm_overwrite, normalize_label_text, natural_sort_key, ensure_subdirectory
+from .utils import (
+    _confirm_overwrite,
+    normalize_label_text,
+    natural_sort_key,
+    ensure_subdirectory,
+    xy_cif_stack_y_offset,
+    xy_cif_tick_stack_layout,
+    xy_cif_add_phase_title,
+    xy_cif_row_spacing_yr,
+    xy_cif_stack_bottom_margin_yr,
+)
 from .readers import (
     read_csv_file,
     read_fullprof_rowwise,
@@ -3411,25 +3421,30 @@ def batplot_main() -> int:  # type: ignore
                         except Exception:
                             pass
                     
-                    # Calculate base and spacing based on FIXED y-axis limits (not current)
-                    # This prevents incremental movement when toggling
-                    if saved_stack or len(y_data_list) > 1:
+                    _stacked_s = bool(saved_stack or len(y_data_list) > 1)
+                    if _stacked_s:
                         global_min = min(float(a.min()) for a in y_data_list if len(a)) if y_data_list else fixed_ylim[0]
-                        base = global_min - 0.08*fixed_yr; spacing = 0.05*fixed_yr
+                        base = global_min - 0.08 * fixed_yr
                     else:
                         global_min = min(float(a.min()) for a in y_data_list if len(a)) if y_data_list else 0.0
-                        base = global_min - 0.06*fixed_yr; spacing = 0.04*fixed_yr
-                    
-                    # Only adjust y-axis limits if titles are visible
-                    needed_min = base - (len(cif_tick_series)-1)*spacing - 0.04*fixed_yr
-                    if show_titles_local and needed_min < fixed_ylim[0]:
-                        # Expand y-axis only if needed, using fixed limits as reference
-                        ax.set_ylim(needed_min, fixed_ylim[1])
+                        base = global_min - 0.06 * fixed_yr
+                    spacing = xy_cif_row_spacing_yr(
+                        fixed_yr,
+                        show_titles=show_titles_local,
+                        show_hkl=show_hkl_local,
+                        stacked_or_multi_y=_stacked_s,
+                    )
+                    _cif_bottom_m = xy_cif_stack_bottom_margin_yr(fixed_yr, show_titles=show_titles_local)
+                    needed_min = base - (len(cif_tick_series) - 1) * spacing - _cif_bottom_m
+                    if not show_titles_local:
+                        ylim_draw = tuple(prev_ylim)
+                    elif needed_min >= prev_ylim[0]:
+                        ylim_draw = tuple(prev_ylim)
                     else:
-                        # Restore to fixed limits if no expansion needed
-                        ax.set_ylim(fixed_ylim)
-                    
-                    # Get current limits for drawing (after potential expansion)
+                        new_ymin = min(needed_min, prev_ylim[0])
+                        ylim_draw = (new_ymin, prev_ylim[1])
+                    ax.set_ylim(ylim_draw)
+
                     cur_ylim = ax.get_ylim()
                     yr = cur_ylim[1] - cur_ylim[0]
                     if yr <= 0: yr = 1.0
@@ -3443,7 +3458,8 @@ def batplot_main() -> int:  # type: ignore
                     
                     # Draw each series
                     for i,(lab,fname,peaksQ,wl,qmax_sim,color) in enumerate(cif_tick_series):
-                        y_line = base - i*spacing
+                        y_line = base - i * spacing + xy_cif_stack_y_offset(fig, i)
+                        tick_h, hkl_y = xy_cif_tick_stack_layout(y_line, yr)
                         # Convert peaks to axis domain
                         if use_2th:
                             wl_use = wl if wl is not None else wl_any
@@ -3463,7 +3479,7 @@ def batplot_main() -> int:  # type: ignore
                             label_map = {}  # Clear label map if too many peaks
                         for p in domain_peaks:
                             # Use color from tuple (preserved from session)
-                            ln, = ax.plot([p,p],[y_line, y_line+0.02*yr], color=color, lw=1.0, alpha=0.9, zorder=3)
+                            ln, = ax.plot([p, p], [y_line, y_line + tick_h], color=color, lw=1.0, alpha=0.9, zorder=3)
                             new_art.append(ln)
                             # Only show hkl labels if explicitly enabled
                             if show_hkl_local:
@@ -3476,32 +3492,17 @@ def batplot_main() -> int:  # type: ignore
                                 Qp_rounded = round(Qp, 6)
                                 lbl = label_map.get(Qp_rounded)
                                 if lbl:
-                                    # Use same color as tick line
-                                    t_hkl = ax.text(p, y_line+0.022*yr, lbl, ha='center', va='bottom', fontsize=7, rotation=90, color=color)
+                                    t_hkl = ax.text(p, hkl_y, lbl, ha='center', va='bottom', fontsize=7, rotation=90, color=color)
                                     new_art.append(t_hkl)
                         # Only add title label if show_cif_titles is True
                         if show_titles_local:
                             label_text = f" {lab}"
-                            # Align CIF title baseline with tick baseline for this row
-                            txt = ax.text(prev_xlim[0], y_line, label_text,
-                                          ha='left', va='bottom', fontsize=max(8,int(0.55*plt.rcParams.get('font.size',16))), color=color)
-                            new_art.append(txt)
+                            xy_cif_add_phase_title(
+                                ax, prev_xlim[0], y_line, tick_h, label_text,
+                                max(8, int(0.55 * plt.rcParams.get('font.size', 16))), color, new_art,
+                            )
                     ax._cif_tick_art = new_art
-                    # Restore x-axis limits
                     ax.set_xlim(prev_xlim)
-                    # Restore y-axis: if titles are hidden, always restore; if titles are shown, only restore if we didn't need to expand
-                    # Use prev_ylim (current limits before drawing) to prevent any movement
-                    if not show_titles_local:
-                        # Titles hidden: always restore original limits
-                        ax.set_ylim(prev_ylim)
-                    elif needed_min >= prev_ylim[0]:
-                        # Titles shown but no expansion needed: restore original limits
-                        ax.set_ylim(prev_ylim)
-                    else:
-                        # Expansion needed: use the minimum of needed_min and prev_ylim[0] to prevent incremental growth
-                        # This ensures that repeated toggles don't cause drift
-                        new_ymin = min(needed_min, prev_ylim[0])
-                        ax.set_ylim(new_ymin, prev_ylim[1])
                     fig.canvas.draw_idle()
                 except Exception:
                     pass
@@ -4496,25 +4497,50 @@ def batplot_main() -> int:  # type: ignore
         else:
             n_rows = max(1, sum(1 for v in set_visible if v))
         
+        show_hkl_for_spacing = False
+        try:
+            _bp_module_sp = sys.modules.get('__main__')
+            if _bp_module_sp is not None and hasattr(_bp_module_sp, 'show_cif_hkl'):
+                show_hkl_for_spacing = bool(getattr(_bp_module_sp, 'show_cif_hkl', False))
+        except Exception:
+            pass
+        if not show_hkl_for_spacing:
+            try:
+                show_hkl_for_spacing = bool(globals().get('show_cif_hkl', False))
+            except Exception:
+                pass
+        
+        stacked_data = bool(args.stack or len(y_data_list) > 1)
         # Calculate base and spacing based on FIXED y-axis limits (not current)
         # This prevents incremental movement when toggling
-        if args.stack or len(y_data_list) > 1:
+        if stacked_data:
             global_min = min(float(a.min()) for a in y_data_list if len(a)) if y_data_list else fixed_ylim[0]
-            base = global_min - 0.08*fixed_yr; spacing = 0.05*fixed_yr
+            base = global_min - 0.08 * fixed_yr
         else:
             global_min = min(float(a.min()) for a in y_data_list if len(a)) if y_data_list else 0.0
-            base = global_min - 0.06*fixed_yr; spacing = 0.04*fixed_yr
+            base = global_min - 0.06 * fixed_yr
+        spacing = xy_cif_row_spacing_yr(
+            fixed_yr,
+            show_titles=show_titles,
+            show_hkl=show_hkl_for_spacing,
+            stacked_or_multi_y=stacked_data,
+        )
+        bottom_margin = xy_cif_stack_bottom_margin_yr(fixed_yr, show_titles=show_titles)
         
         # Only adjust y-axis limits if titles are visible
-        needed_min = base - (n_rows-1)*spacing - 0.04*fixed_yr
-        if show_titles and needed_min < fixed_ylim[0]:
-            # Expand y-axis only if needed, using fixed limits as reference
-            ax.set_ylim(needed_min, fixed_ylim[1])
+        needed_min = base - (n_rows - 1) * spacing - bottom_margin
+        # One y-limit state for the whole draw: must match what we keep after drawing.
+        # Previously we set ylim to fixed_ylim / (needed_min, fixed_ylim[1]), drew with that yr,
+        # then replaced ylim with prev_ylim — different ymax/yr broke title–tick alignment per row.
+        if not show_titles:
+            ylim_draw = tuple(prev_ylim)
+        elif needed_min >= prev_ylim[0]:
+            ylim_draw = tuple(prev_ylim)
         else:
-            # Restore to fixed limits if no expansion needed
-            ax.set_ylim(fixed_ylim)
-        
-        # Get current limits for drawing (after potential expansion)
+            new_ymin = min(needed_min, prev_ylim[0])
+            ylim_draw = (new_ymin, prev_ylim[1])
+        ax.set_ylim(ylim_draw)
+
         cur_ylim = ax.get_ylim()
         yr = cur_ylim[1] - cur_ylim[0]
         if yr <= 0: yr = 1.0
@@ -4543,7 +4569,8 @@ def batplot_main() -> int:  # type: ignore
         for i,(lab, fname, peaksQ, wl, qmax_sim, color) in enumerate(cif_tick_series):
             if set_visible is not None and i < len(set_visible) and not set_visible[i]:
                 continue
-            y_line = base - visible_idx*spacing
+            y_line = base - visible_idx * spacing + xy_cif_stack_y_offset(fig, i)
+            tick_h, hkl_y = xy_cif_tick_stack_layout(y_line, yr)
             if use_2th:
                 if wl is None: wl = _ensure_wavelength_for_2theta()
                 domain_peaks = _Q_to_2theta(peaksQ, wl)
@@ -4559,10 +4586,11 @@ def batplot_main() -> int:  # type: ignore
                 if show_titles:
                     # Removed numbering; keep space padding
                     label_text = f" {lab}"
-                    # Align CIF title baseline with tick baseline for this row
-                    txt = ax.text(prev_xlim[0], y_line, label_text,
-                                  ha='left', va='bottom', fontsize=max(8,int(0.55*plt.rcParams.get('font.size',12))), color=color)
-                    new_art.append(txt)
+                    xy_cif_add_phase_title(
+                        ax, prev_xlim[0], y_line, tick_h, label_text,
+                        max(8, int(0.55 * plt.rcParams.get('font.size', 12))), color, new_art,
+                    )
+                visible_idx += 1
                 continue
             # Build map for quick hkl lookup by Q (only if hkl labels are enabled)
             label_map = {}
@@ -4585,7 +4613,7 @@ def batplot_main() -> int:  # type: ignore
             if effective_show_hkl:
                 # For 2θ axis we convert back to Q then round; otherwise Q directly
                 for p in domain_peaks:
-                    ln, = ax.plot([p,p],[y_line, y_line+0.02*yr], color=color, lw=1.0, alpha=0.9, zorder=3)
+                    ln, = ax.plot([p, p], [y_line, y_line + tick_h], color=color, lw=1.0, alpha=0.9, zorder=3)
                     new_art.append(ln)
                     if use_2th and wl:
                         theta = np.radians(p/2.0)
@@ -4595,37 +4623,25 @@ def batplot_main() -> int:  # type: ignore
                     Qp_rounded = round(Qp, 6)
                     lbl = label_map.get(Qp_rounded)
                     if lbl:
-                        t_hkl = ax.text(p, y_line+0.022*yr, lbl, ha='center', va='bottom', fontsize=7, rotation=90, color=color)
+                        t_hkl = ax.text(p, hkl_y, lbl, ha='center', va='bottom', fontsize=7, rotation=90, color=color)
                         new_art.append(t_hkl)
             else:
                 # Just draw ticks (no hkl labels)
                 for p in domain_peaks:
-                    ln, = ax.plot([p,p],[y_line, y_line+0.02*yr], color=color, lw=1.0, alpha=0.9, zorder=3)
+                    ln, = ax.plot([p, p], [y_line, y_line + tick_h], color=color, lw=1.0, alpha=0.9, zorder=3)
                     new_art.append(ln)
             # Removed numbering; keep space padding (placed per CIF row)
             # Only add title label if show_cif_titles is True
             if show_titles:
                 label_text = f" {lab}"
-                # Align CIF title baseline with tick baseline for this row
-                txt = ax.text(prev_xlim[0], y_line, label_text,
-                              ha='left', va='bottom', fontsize=max(8,int(0.55*plt.rcParams.get('font.size',12))), color=color)
-                new_art.append(txt)
+                xy_cif_add_phase_title(
+                    ax, prev_xlim[0], y_line, tick_h, label_text,
+                    max(8, int(0.55 * plt.rcParams.get('font.size', 12))), color, new_art,
+                )
             visible_idx += 1
         ax._cif_tick_art = new_art
-        # Restore both x and y-axis limits to prevent movement
         ax.set_xlim(prev_xlim)
-        # Restore y-axis: if titles are hidden, always restore; if titles are shown, only restore if we didn't need to expand
-        if not show_titles:
-            # Titles hidden: always restore original limits
-            ax.set_ylim(prev_ylim)
-        elif needed_min >= prev_ylim[0]:
-            # Titles shown but no expansion needed: restore original limits
-            ax.set_ylim(prev_ylim)
-        else:
-            # Expansion needed: use the minimum of needed_min and prev_ylim[0] to prevent incremental growth
-            # This ensures that repeated toggles don't cause drift
-            new_ymin = min(needed_min, prev_ylim[0])
-            ax.set_ylim(new_ymin, prev_ylim[1])
+        # y-axis already set to ylim_draw before draw; avoid second set_ylim (changed yr vs. tick/title geometry)
         # Store simplified metadata for hover: list of dicts with 'x','y','label'
         hover_meta = []
         show_hkl = globals().get('show_cif_hkl', False)
@@ -4643,14 +4659,25 @@ def batplot_main() -> int:  # type: ignore
             domain_peaks = [p for p in domain_peaks if xlow <= p <= xhigh]
             if not domain_peaks:
                 continue
-            # y baseline for this series (same logic as above)
-            if args.stack or len(y_data_list) > 1:
+            # y baseline for this series (same spacing as main CIF draw)
+            show_hkl_h = bool(globals().get('show_cif_hkl', False))
+            try:
+                _bm = sys.modules.get('__main__')
+                if _bm is not None and hasattr(_bm, 'show_cif_hkl'):
+                    show_hkl_h = bool(getattr(_bm, 'show_cif_hkl', False))
+            except Exception:
+                pass
+            _stacked = bool(args.stack or len(y_data_list) > 1)
+            if _stacked:
                 global_min = min(float(a.min()) for a in y_data_list if len(a)) if y_data_list else ax.get_ylim()[0]
-                base = global_min - 0.08*yr; spacing = 0.05*yr
+                base = global_min - 0.08 * yr
             else:
                 global_min = min(float(a.min()) for a in y_data_list if len(a)) if y_data_list else 0.0
-                base = global_min - 0.06*yr; spacing = 0.04*yr
-            y_line = base - i*spacing
+                base = global_min - 0.06 * yr
+            spacing = xy_cif_row_spacing_yr(
+                yr, show_titles=show_titles, show_hkl=show_hkl_h, stacked_or_multi_y=_stacked
+            )
+            y_line = base - i * spacing + xy_cif_stack_y_offset(fig, i)
             label_map = cif_hkl_label_map.get(fname, {}) if show_hkl else {}
             for p in domain_peaks:
                 if use_2th and wl:

{batplot-1.8.34 → batplot-1.8.36}/batplot/data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [1.8.36] - 2026-03-30
+- Bug fixes
+
+
+## [1.8.35] - 2026-03-26
+- Bug fixes
+
+
 ## [1.8.34] - 2026-03-24
 - Bug fixes
 

{batplot-1.8.34 → batplot-1.8.36}/batplot/electrochem_interactive.py

@@ -281,12 +281,24 @@ def _apply_stored_smooth_settings(cycle_lines: Dict[int, Dict[str, Optional[Any]
                     continue
                 xdata = np.asarray(ln.get_xdata(), float)
                 ydata = np.asarray(ln.get_ydata(), float)
+                if xdata.size != ydata.size:
+                    n = int(min(xdata.size, ydata.size))
+                    if n < 3:
+                        continue
+                    xdata = xdata[:n]
+                    ydata = ydata[:n]
                 if xdata.size < 3:
                     continue
                 # Get original data if available, otherwise use current data
                 if hasattr(ln, '_original_xdata'):
                     xdata = np.asarray(ln._original_xdata, float)
                     ydata = np.asarray(ln._original_ydata, float)
+                    if xdata.size != ydata.size:
+                        n = int(min(xdata.size, ydata.size))
+                        if n < 3:
+                            continue
+                        xdata = xdata[:n]
+                        ydata = ydata[:n]
                 else:
                     ln._original_xdata = np.array(xdata, copy=True)
                     ln._original_ydata = np.array(ydata, copy=True)
@@ -309,12 +321,24 @@ def _apply_stored_smooth_settings(cycle_lines: Dict[int, Dict[str, Optional[Any]
                     continue
                 xdata = np.asarray(ln.get_xdata(), float)
                 ydata = np.asarray(ln.get_ydata(), float)
+                if xdata.size != ydata.size:
+                    n = int(min(xdata.size, ydata.size))
+                    if n < 3:
+                        continue
+                    xdata = xdata[:n]
+                    ydata = ydata[:n]
                 if xdata.size < 3:
                     continue
                 # Get original data if available, otherwise use current data
                 if hasattr(ln, '_original_xdata'):
                     xdata = np.asarray(ln._original_xdata, float)
                     ydata = np.asarray(ln._original_ydata, float)
+                    if xdata.size != ydata.size:
+                        n = int(min(xdata.size, ydata.size))
+                        if n < 3:
+                            continue
+                        xdata = xdata[:n]
+                        ydata = ydata[:n]
                 else:
                     ln._original_xdata = np.array(xdata, copy=True)
                     ln._original_ydata = np.array(ydata, copy=True)
@@ -341,12 +365,24 @@ def _apply_stored_smooth_settings(cycle_lines: Dict[int, Dict[str, Optional[Any]
                     continue
                 xdata = np.asarray(ln.get_xdata(), float)
                 ydata = np.asarray(ln.get_ydata(), float)
+                if xdata.size != ydata.size:
+                    n = int(min(xdata.size, ydata.size))
+                    if n < 5:
+                        continue
+                    xdata = xdata[:n]
+                    ydata = ydata[:n]
                 if xdata.size < 5:
                     continue
                 # Get original data if available, otherwise use current data
                 if hasattr(ln, '_original_xdata'):
                     xdata = np.asarray(ln._original_xdata, float)
                     ydata = np.asarray(ln._original_ydata, float)
+                    if xdata.size != ydata.size:
+                        n = int(min(xdata.size, ydata.size))
+                        if n < 5:
+                            continue
+                        xdata = xdata[:n]
+                        ydata = ydata[:n]
                 else:
                     ln._original_xdata = np.array(xdata, copy=True)
                     ln._original_ydata = np.array(ydata, copy=True)
@@ -5741,27 +5777,33 @@ def electrochem_interactive_menu(fig, ax, cycle_lines: Optional[Dict[int, Dict[s
                                     if ln is None or not ln.get_visible():
                                         continue
                                     xdata = np.asarray(ln.get_xdata(), float)
-                                ydata = np.asarray(ln.get_ydata(), float)
-                                if xdata.size < 3:
-                                    continue
-                                if not hasattr(ln, '_original_xdata'):
-                                    ln._original_xdata = np.array(xdata, copy=True)
-                                    ln._original_ydata = np.array(ydata, copy=True)
-                                dv = np.abs(np.diff(xdata))
-                                mask = np.ones_like(xdata, dtype=bool)
-                                mask[1:] &= dv >= threshold_v
-                                mask[:-1] &= dv >= threshold_v
-                                filtered_x = xdata[mask]
-                                filtered_y = ydata[mask]
-                                before = len(xdata)
-                                after = len(filtered_x)
-                                if after < before:
-                                    ln.set_xdata(filtered_x)
-                                    ln.set_ydata(filtered_y)
-                                    ln._smooth_applied = True
-                                    filtered += 1
-                                    total_before += before
-                                    total_after += after
+                                    ydata = np.asarray(ln.get_ydata(), float)
+                                    if xdata.size != ydata.size:
+                                        n = int(min(xdata.size, ydata.size))
+                                        if n < 3:
+                                            continue
+                                        xdata = xdata[:n]
+                                        ydata = ydata[:n]
+                                    if xdata.size < 3:
+                                        continue
+                                    if not hasattr(ln, '_original_xdata'):
+                                        ln._original_xdata = np.array(xdata, copy=True)
+                                        ln._original_ydata = np.array(ydata, copy=True)
+                                    dv = np.abs(np.diff(xdata))
+                                    mask = np.ones_like(xdata, dtype=bool)
+                                    mask[1:] &= dv >= threshold_v
+                                    mask[:-1] &= dv >= threshold_v
+                                    filtered_x = xdata[mask]
+                                    filtered_y = ydata[mask]
+                                    before = len(xdata)
+                                    after = len(filtered_x)
+                                    if after < before:
+                                        ln.set_xdata(filtered_x)
+                                        ln.set_ydata(filtered_y)
+                                        ln._smooth_applied = True
+                                        filtered += 1
+                                        total_before += before
+                                        total_after += after
                         if filtered:
                             removed = total_before - total_after
                             pct = 100 * removed / total_before if total_before else 0
@@ -5867,6 +5909,12 @@ def electrochem_interactive_menu(fig, ax, cycle_lines: Optional[Dict[int, Dict[s
                                     continue
                                 xdata = np.asarray(ln.get_xdata(), float)
                                 ydata = np.asarray(ln.get_ydata(), float)
+                                if xdata.size != ydata.size:
+                                    n = int(min(xdata.size, ydata.size))
+                                    if n < 3:
+                                        continue
+                                    xdata = xdata[:n]
+                                    ydata = ydata[:n]
                                 if xdata.size < 3:
                                     continue
                                 if not hasattr(ln, '_original_xdata'):
@@ -5976,6 +6024,12 @@ def electrochem_interactive_menu(fig, ax, cycle_lines: Optional[Dict[int, Dict[s
                                         continue
                                     xdata = np.asarray(ln.get_xdata(), float)
                                     ydata = np.asarray(ln.get_ydata(), float)
+                                    if xdata.size != ydata.size:
+                                        n = int(min(xdata.size, ydata.size))
+                                        if n < 5:
+                                            continue
+                                        xdata = xdata[:n]
+                                        ydata = ydata[:n]
                                     if xdata.size < 5:
                                         continue
                                     if not hasattr(ln, '_original_xdata'):

{batplot-1.8.34 → batplot-1.8.36}/batplot/interactive.py

@@ -33,6 +33,7 @@ from .utils import (
     get_organized_path,
     natural_sort_key,
     print_label_latex_tips,
+    normalize_xy_cif_stack_y_offsets,
 )
 import time
 from .session import dump_session as _bp_dump_session
@@ -1636,6 +1637,10 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
                     snap["cif_set_visible"] = list(getattr(_bp_module_snap, 'cif_set_visible') or [])
             except Exception:
                 pass
+            try:
+                snap["cif_stack_y_offsets"] = list(getattr(fig, '_bp_cif_stack_y_offsets', []) or [])
+            except Exception:
+                pass
             # Line + data arrays
             for i, ln in _iter_lines():
                 snap["lines"].append({
@@ -2039,6 +2044,11 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
                         _bp_module.cif_set_visible = list(snap['cif_set_visible'])
                 except Exception:
                     pass
+            if 'cif_stack_y_offsets' in snap:
+                try:
+                    fig._bp_cif_stack_y_offsets = list(snap['cif_stack_y_offsets'])
+                except Exception:
+                    pass
             # Redraw CIF ticks after restoration if available
             if hasattr(ax, '_cif_draw_func'):
                 try:
@@ -2131,11 +2141,12 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
                 # Accept both 'j' (legacy) and 't' (to match operando) for title toggle
                 print("  " + colorize_menu(titles_desc))
                 print("  " + colorize_menu(order_desc))
+                print("  " + colorize_menu("p: shift all CIF ticks (w/s or type a value)"))
                 print("  " + colorize_menu("c: CIF color (per set)"))
                 print("  " + colorize_menu("x: show/hide CIF set"))
                 print("  " + colorize_menu("r: rename CIF set label"))
                 print("  " + colorize_menu("q: back to main menu"))
-                sub = _safe_input(colorize_prompt("CIF (c/x/r/q): ")).strip().lower()
+                sub = _safe_input(colorize_prompt("CIF (z/t/v/p/c/x/r/q): ")).strip().lower()
                 if not sub or sub == 'q':
                     break
                 if sub == 'z':
@@ -2238,11 +2249,94 @@ def interactive_menu(fig, ax, y_data_list, x_data_list, labels, orig_y,
                             new_cts = [cts[i - 1] for i in parts]
                             if _bp is not None:
                                 setattr(_bp, 'cif_tick_series', new_cts)
+                            prev_offs = getattr(fig, '_bp_cif_stack_y_offsets', None)
+                            if prev_offs is not None and len(prev_offs) == len(cts):
+                                fig._bp_cif_stack_y_offsets = [prev_offs[i - 1] for i in parts]
                             if hasattr(ax, '_cif_draw_func'):
                                 ax._cif_draw_func()
                             print("Updated CIF vertical order.")
                     except Exception as e:
                         print(f"Error reordering CIF sets: {e}")
+                elif sub == 'p':
+                    # Same offset list length as CIF sets: apply one shared data-Y shift to every row,
+                    # or w/s nudge all stacks by fixed typographic points on screen (2 pt).
+                    _CIF_NUDGE_PT = 2.0
+
+                    def _dy_data_for_display_pts(ax_, dy_pts):
+                        try:
+                            x_ref = float(np.mean(ax_.get_xlim()))
+                            y_ref = float(np.mean(ax_.get_ylim()))
+                            p0 = np.asarray(ax_.transData.transform((x_ref, y_ref)), dtype=float)
+                            fig_ = ax_.figure
+                            d_pix = float(dy_pts) * (float(fig_.dpi) / 72.0)
+                            p1 = p0 + np.array([0.0, d_pix], dtype=float)
+                            y1 = float(ax_.transData.inverted().transform(tuple(p1))[1])
+                            return y1 - y_ref
+                        except Exception:
+                            return 0.0
+
+                    try:
+                        cts = getattr(_bp, 'cif_tick_series', None) if _bp is not None else None
+                        if not cts:
+                            print("No CIF tick sets.")
+                        else:
+                            n = len(cts)
+                            _Hi = '\033[1m'
+                            _Cc = '\033[96m'
+                            _Rn = '\033[0m'
+                            while True:
+                                normalize_xy_cif_stack_y_offsets(fig, n)
+                                offs = list(fig._bp_cif_stack_y_offsets)
+                                print(
+                                    f"\n{_Hi}All CIF ticks:{_Rn} {_Hi}{_Cc}w{_Rn}/{_Hi}{_Cc}s{_Rn} nudge all "
+                                    f"(±{_CIF_NUDGE_PT:g} pt), or a {_Hi}{_Cc}number{_Rn} for all; "
+                                    f"{_Hi}{_Cc}0{_Rn} clear; {_Hi}{_Cc}q{_Rn} leave."
+                                )
+                                line = _safe_input(colorize_prompt("(w/s/value/0/q): ")).strip().lower()
+                                if not line or line == 'q':
+                                    break
+                                dd = _dy_data_for_display_pts(ax, _CIF_NUDGE_PT)
+                                if line == 'w':
+                                    try:
+                                        push_state("cif-stack-y-offset")
+                                    except Exception:
+                                        pass
+                                    fig._bp_cif_stack_y_offsets = [float(o) + dd for o in offs]
+                                    if hasattr(ax, '_cif_draw_func'):
+                                        ax._cif_draw_func()
+                                    continue
+                                if line == 's':
+                                    try:
+                                        push_state("cif-stack-y-offset")
+                                    except Exception:
+                                        pass
+                                    fig._bp_cif_stack_y_offsets = [float(o) - dd for o in offs]
+                                    if hasattr(ax, '_cif_draw_func'):
+                                        ax._cif_draw_func()
+                                    continue
+                                if line in ('reset', '0', 'zero'):
+                                    try:
+                                        push_state("cif-stack-y-offset")
+                                    except Exception:
+                                        pass
+                                    fig._bp_cif_stack_y_offsets = [0.0] * n
+                                    if hasattr(ax, '_cif_draw_func'):
+                                        ax._cif_draw_func()
+                                    continue
+                                try:
+                                    val = float(line)
+                                except ValueError:
+                                    print("w, s, a number, or q.")
+                                    continue
+                                try:
+                                    push_state("cif-stack-y-offset")
+                                except Exception:
+                                    pass
+                                fig._bp_cif_stack_y_offsets = [float(val)] * n
+                                if hasattr(ax, '_cif_draw_func'):
+                                    ax._cif_draw_func()
+                    except Exception as e:
+                        print(f"Error setting CIF offsets: {e}")
                 elif sub == 'c':
                     # CIF colors: support per-set mappings and palette-like tokens, mirroring main color menu behavior.
                     try:

{batplot-1.8.34 → batplot-1.8.36}/batplot/session.py

@@ -48,7 +48,15 @@ from matplotlib.ticker import (
     NullFormatter, FuncFormatter, MaxNLocator,
 )
 
-from .utils import _confirm_overwrite, ensure_exact_case_filename
+from .utils import (
+    _confirm_overwrite,
+    ensure_exact_case_filename,
+    xy_cif_stack_y_offset,
+    xy_cif_tick_stack_layout,
+    xy_cif_add_phase_title,
+    xy_cif_row_spacing_yr,
+    xy_cif_stack_bottom_margin_yr,
+)
 from .color_utils import ensure_colormap
 from .ui import (
     set_spine_side_color as _set_spine_side_color,
@@ -656,7 +664,18 @@ def dump_session(
             'cif_hkl_label_map': {k: dict(v) for k, v in (cif_hkl_label_map or {}).items()},
             'show_cif_hkl': bool(show_cif_hkl),
             'show_cif_titles': bool(show_cif_titles) if show_cif_titles is not None else True,
+            'cif_stack_y_offsets': list(getattr(fig, '_bp_cif_stack_y_offsets', []) or []),
         }
+        # 1D XY: per-set CIF visibility (__main__.cif_set_visible), same as undo snapshots
+        try:
+            if cif_tick_series:
+                _m = sys.modules.get("__main__")
+                if _m is not None and hasattr(_m, "cif_set_visible"):
+                    _vis = list(getattr(_m, "cif_set_visible") or [])
+                    if len(_vis) == len(list(cif_tick_series or [])):
+                        sess["cif_set_visible"] = [bool(v) for v in _vis]
+        except Exception:
+            pass
         sess['axis_titles'] = {
             'top_x': bool(getattr(ax, '_top_xlabel_on', False)),
             'right_y': bool(getattr(ax, '_right_ylabel_on', False)),
@@ -3969,6 +3988,32 @@ def load_xy_session(filename: str):
                 setattr(_bp_module, 'cif_extend_suspended', False)
         except Exception:
             pass
+        try:
+            co = sess.get('cif_stack_y_offsets')
+            if co is not None and cif_tick_series:
+                olist = []
+                for x in list(co):
+                    try:
+                        olist.append(float(x))
+                    except (TypeError, ValueError):
+                        olist.append(0.0)
+                while len(olist) < len(cif_tick_series):
+                    olist.append(0.0)
+                fig._bp_cif_stack_y_offsets = olist[: len(cif_tick_series)]
+        except Exception:
+            pass
+        try:
+            vis = sess.get("cif_set_visible")
+            if vis is not None and cif_tick_series:
+                vlist = [bool(v) for v in list(vis)]
+                while len(vlist) < len(cif_tick_series):
+                    vlist.append(True)
+                vlist = vlist[: len(cif_tick_series)]
+                _m = sys.modules.get("__main__")
+                if _m is not None:
+                    setattr(_m, "cif_set_visible", vlist)
+        except Exception:
+            pass
 
         axis_mode_restored = sess.get('axis_mode', 'unknown')
         use_Q = axis_mode_restored == 'Q'
@@ -4050,19 +4095,29 @@ def load_xy_session(filename: str):
                         pass
                     if not show_hkl_local:
                         show_hkl_local = bool(show_cif_hkl)
-                    if saved_stack or len(y_data_list) > 1:
+                    _stacked_xy = bool(saved_stack or len(y_data_list) > 1)
+                    if _stacked_xy:
                         global_min = min(float(a.min()) for a in y_data_list if len(a)) if y_data_list else fixed_ylim[0]
                         base = global_min - 0.08 * fixed_yr
-                        spacing = 0.05 * fixed_yr
                     else:
                         global_min = min(float(a.min()) for a in y_data_list if len(a)) if y_data_list else 0.0
                         base = global_min - 0.06 * fixed_yr
-                        spacing = 0.04 * fixed_yr
-                    needed_min = base - (len(cif_tick_series) - 1) * spacing - 0.04 * fixed_yr
-                    if show_titles_local and needed_min < fixed_ylim[0]:
-                        ax.set_ylim(needed_min, fixed_ylim[1])
+                    spacing = xy_cif_row_spacing_yr(
+                        fixed_yr,
+                        show_titles=show_titles_local,
+                        show_hkl=show_hkl_local,
+                        stacked_or_multi_y=_stacked_xy,
+                    )
+                    _cif_bottom_m = xy_cif_stack_bottom_margin_yr(fixed_yr, show_titles=show_titles_local)
+                    needed_min = base - (len(cif_tick_series) - 1) * spacing - _cif_bottom_m
+                    if not show_titles_local:
+                        ylim_draw = tuple(prev_ylim)
+                    elif needed_min >= prev_ylim[0]:
+                        ylim_draw = tuple(prev_ylim)
                     else:
-                        ax.set_ylim(fixed_ylim)
+                        new_ymin = min(needed_min, prev_ylim[0])
+                        ylim_draw = (new_ymin, prev_ylim[1])
+                    ax.set_ylim(ylim_draw)
                     cur_ylim = ax.get_ylim()
                     yr = cur_ylim[1] - cur_ylim[0]
                     if yr <= 0:
@@ -4075,7 +4130,8 @@ def load_xy_session(filename: str):
                     new_art = []
                     wl_any = _session_ensure_wavelength()
                     for i, (lab, fname, peaksQ, wl, qmax_sim, color) in enumerate(cif_tick_series):
-                        y_line = base - i * spacing
+                        y_line = base - i * spacing + xy_cif_stack_y_offset(fig, i)
+                        tick_h, hkl_y = xy_cif_tick_stack_layout(y_line, yr)
                         if use_2th:
                             wl_use = wl if wl is not None else wl_any
                             domain_peaks = _session_q_to_2theta(peaksQ, wl_use)
@@ -4090,7 +4146,7 @@ def load_xy_session(filename: str):
                             show_hkl_local = False
                             label_map = {}
                         for p in domain_peaks:
-                            ln, = ax.plot([p, p], [y_line, y_line + 0.02 * yr], color=color, lw=1.0, alpha=0.9, zorder=3)
+                            ln, = ax.plot([p, p], [y_line, y_line + tick_h], color=color, lw=1.0, alpha=0.9, zorder=3)
                             new_art.append(ln)
                             if show_hkl_local:
                                 if use_2th and (wl or wl_any):
@@ -4101,24 +4157,17 @@ def load_xy_session(filename: str):
                                 Qp_rounded = round(Qp, 6)
                                 lbl = label_map.get(Qp_rounded)
                                 if lbl:
-                                    t_hkl = ax.text(p, y_line + 0.022 * yr, lbl, ha='center', va='bottom',
+                                    t_hkl = ax.text(p, hkl_y, lbl, ha='center', va='bottom',
                                                     fontsize=7, rotation=90, color=color)
                                     new_art.append(t_hkl)
                         if show_titles_local:
                             label_text = f" {lab}"
-                            txt = ax.text(prev_xlim[0], y_line, label_text,
-                                          ha='left', va='bottom',
-                                          fontsize=max(8, int(0.55 * plt.rcParams.get('font.size', 16))), color=color)
-                            new_art.append(txt)
+                            xy_cif_add_phase_title(
+                                ax, prev_xlim[0], y_line, tick_h, label_text,
+                                max(8, int(0.55 * plt.rcParams.get('font.size', 16))), color, new_art,
+                            )
                     ax._cif_tick_art = new_art
                     ax.set_xlim(prev_xlim)
-                    if not show_titles_local:
-                        ax.set_ylim(prev_ylim)
-                    elif needed_min >= prev_ylim[0]:
-                        ax.set_ylim(prev_ylim)
-                    else:
-                        new_ymin = min(needed_min, prev_ylim[0])
-                        ax.set_ylim(new_ymin, prev_ylim[1])
                     fig.canvas.draw_idle()
                 except Exception:
                     pass

{batplot-1.8.34 → batplot-1.8.36}/batplot/style.py

@@ -530,19 +530,37 @@ def print_style_info(
     print(f"Label anchor: {legend_pos} (stack={getattr(args, 'stack', False)})")
     print(f"Labels (r): x='{ax.get_xlabel() or ''}', y='{ax.get_ylabel() or ''}'")
 
-    # ---- CIF (z, j) ---
-    if show_cif_hkl is not None:
-        print(f"\n--- CIF (z, j) ---")
-        print(f"CIF hkl labels (z): {'shown' if show_cif_hkl else 'hidden'}")
-    elif cif_tick_series:
+    # ---- CIF (cif submenu: z, t, v, p, …) ---
+    if cif_tick_series:
+        print(f"\n--- CIF (cif key) ---")
         try:
+            hkl_state = None
             _bp_module = sys.modules.get('__main__')
             if _bp_module is not None and hasattr(_bp_module, 'show_cif_hkl'):
                 hkl_state = bool(getattr(_bp_module, 'show_cif_hkl', False))
-                print(f"\n--- CIF (z, j) ---")
+            elif show_cif_hkl is not None:
+                hkl_state = bool(show_cif_hkl)
+            if hkl_state is not None:
                 print(f"CIF hkl labels (z): {'shown' if hkl_state else 'hidden'}")
+            off_list = getattr(fig, '_bp_cif_stack_y_offsets', None) or []
+            if off_list:
+                bits = []
+                for i, ent in enumerate(cif_tick_series):
+                    lab = ent[0] if ent else f"set{i+1}"
+                    ov = float(off_list[i]) if i < len(off_list) else 0.0
+                    if abs(ov) > 1e-12:
+                        bits.append(f"{lab}={ov:.4g}")
+                if bits:
+                    print("CIF stack Y offsets (p): " + "; ".join(bits))
+                else:
+                    print("CIF stack Y offsets (p): all 0")
+            else:
+                print("CIF stack Y offsets (p): default (0 per set)")
         except Exception:
             pass
+    elif show_cif_hkl is not None:
+        print(f"\n--- CIF ---")
+        print(f"CIF hkl labels (z): {'shown' if show_cif_hkl else 'hidden'}")
 
     # ---- Curves (c, o) ----
     print("\n--- Curves (c, o) ---")
@@ -772,6 +790,17 @@ def export_style_config(
                 {"index": i, "color": color}
                 for i, (lab, fname, peaksQ, wl, qmax_sim, color) in enumerate(cif_tick_series)
             ]
+            # Always save one offset per CIF set so import (i) matches session/undo (s/b).
+            raw_off = getattr(fig, "_bp_cif_stack_y_offsets", None) or []
+            o2: List[float] = []
+            for x in list(raw_off)[: len(cif_tick_series)]:
+                try:
+                    o2.append(float(x))
+                except (TypeError, ValueError):
+                    o2.append(0.0)
+            while len(o2) < len(cif_tick_series):
+                o2.append(0.0)
+            cfg["cif_stack_y_offsets"] = o2
         palette_history = getattr(fig, '_curve_palette_history', None)
         if palette_history:
             serialized_palettes = []
@@ -1402,6 +1431,20 @@ def apply_style_config(
                     lab_new = entry.get("label", lab)
                     color_new = entry.get("color", color_old)
                     cif_tick_series[idx] = (lab_new, fname, peaksQ, wl, qmax_sim, color_new)
+        if "cif_stack_y_offsets" in cfg and cif_tick_series is not None:
+            try:
+                raw_o = cfg.get("cif_stack_y_offsets") or []
+                o2 = []
+                for x in list(raw_o)[: len(cif_tick_series)]:
+                    try:
+                        o2.append(float(x))
+                    except (TypeError, ValueError):
+                        o2.append(0.0)
+                while len(o2) < len(cif_tick_series):
+                    o2.append(0.0)
+                fig._bp_cif_stack_y_offsets = o2
+            except Exception:
+                pass
         # Restore CIF title visibility
         if "show_cif_titles" in cfg:
             try:
@@ -1463,7 +1506,8 @@ def apply_style_config(
         # as style files are for styling only, and the data would be specific
         # to the dataset. Session files (pickle) store this data instead.
         # Redraw CIF ticks after applying changes
-        if (cif_cfg and cif_tick_series is not None) or "show_cif_titles" in cfg or "show_cif_hkl" in cfg:
+        if ((cif_cfg and cif_tick_series is not None) or "show_cif_titles" in cfg or "show_cif_hkl" in cfg
+                or "cif_stack_y_offsets" in cfg):
             if hasattr(ax, "_cif_draw_func"):
                 try:
                     ax._cif_draw_func()

{batplot-1.8.34 → batplot-1.8.36}/batplot/utils.py

@@ -41,6 +41,8 @@ import subprocess
 import time
 from typing import Callable, List, Optional, Tuple
 
+from matplotlib.transforms import offset_copy
+
 
 def natural_sort_key(name: str) -> list:
     """Generate a natural sorting key for filenames with numbers.
@@ -1139,3 +1141,122 @@ def choose_style_file(file_paths: List[str], purpose: str = "style import", exte
         if path:
             return path
         print("File not found. Enter another value or use 'c' for custom dialog.")
+
+
+def xy_cif_stack_y_offset(fig, index: int) -> float:
+    """Vertical offset in data Y for CIF stack row ``index`` (XY / 1D mode)."""
+    offs = getattr(fig, "_bp_cif_stack_y_offsets", None)
+    if not offs or index < 0 or index >= len(offs):
+        return 0.0
+    try:
+        return float(offs[index])
+    except (TypeError, ValueError):
+        return 0.0
+
+
+# Typographic gap (screen points) from tick top to phase filename; same for every row / file.
+XY_CIF_TITLE_ABOVE_TICK_PT = 2.0
+
+
+def xy_cif_add_phase_title(
+    ax,
+    x_left: float,
+    y_line: float,
+    tick_h: float,
+    label_text: str,
+    fontsize,
+    color,
+    new_art: list,
+) -> None:
+    """Draw phase filename a fixed number of points above tick tops (uniform visual gap).
+
+    Anchor in data space at the tick tops ``(x_left, y_line + tick_h)``, then shift in
+    **display points** via ``offset_copy`` (matplotlib's stable pattern for data+pt mix).
+    """
+    fig = ax.figure
+    trans = offset_copy(
+        ax.transData,
+        fig=fig,
+        x=0.0,
+        y=XY_CIF_TITLE_ABOVE_TICK_PT,
+        units="points",
+    )
+    txt = ax.text(
+        float(x_left),
+        float(y_line + tick_h),
+        label_text,
+        transform=trans,
+        ha="left",
+        va="bottom",
+        fontsize=fontsize,
+        color=color,
+        clip_on=False,
+        zorder=4,
+    )
+    new_art.append(txt)
+
+
+def xy_cif_tick_stack_layout(y_line: float, yr: float):
+    """Return (tick_h, hkl_text_y) for CIF tick geometry in data coordinates.
+
+    Phase titles use :func:`xy_cif_add_phase_title` (points above ``y_line + tick_h``).
+    """
+    yr = max(float(yr), 1e-12)
+    tick_h = 0.02 * yr
+    hkl_y = y_line + tick_h + 0.005 * yr
+    return tick_h, hkl_y
+
+
+def xy_cif_row_spacing_yr(
+    yr_ref: float,
+    *,
+    show_titles: bool,
+    show_hkl: bool,
+    stacked_or_multi_y: bool,
+) -> float:
+    """Vertical gap between consecutive CIF row baselines (``y_line``), in data Y units.
+
+    Must be large enough that phase titles (above tick stems) and optional rotated
+    hkl labels do not collide with the next row.
+    """
+    yr = max(float(yr_ref), 1e-12)
+    if stacked_or_multi_y:
+        spacing = 0.05 * yr
+    else:
+        spacing = 0.04 * yr
+    if show_titles and show_hkl:
+        spacing = max(spacing, 0.088 * yr)
+    elif show_titles:
+        spacing = max(spacing, 0.076 * yr)
+    elif show_hkl:
+        spacing = max(spacing, 0.056 * yr)
+    return float(spacing)
+
+
+def xy_cif_stack_bottom_margin_yr(yr_ref: float, *, show_titles: bool) -> float:
+    """Extra room below the lowest CIF row (fraction of ``yr_ref``) for axis padding."""
+    yr = max(float(yr_ref), 1e-12)
+    if show_titles:
+        return float(0.055 * yr)
+    return float(0.04 * yr)
+
+
+def normalize_xy_cif_stack_y_offsets(fig, n_sets: int) -> list:
+    """Ensure ``fig._bp_cif_stack_y_offsets`` exists and has length ``n_sets``."""
+    if n_sets <= 0:
+        fig._bp_cif_stack_y_offsets = []
+        return []
+    cur = getattr(fig, "_bp_cif_stack_y_offsets", None)
+    if cur is None:
+        out = [0.0] * n_sets
+    else:
+        out = []
+        for x in list(cur)[:n_sets]:
+            try:
+                out.append(float(x))
+            except (TypeError, ValueError):
+                out.append(0.0)
+        if len(out) < n_sets:
+            out.extend([0.0] * (n_sets - len(out)))
+    fig._bp_cif_stack_y_offsets = out
+    return out

{batplot-1.8.34 → batplot-1.8.36/batplot.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: batplot
-Version: 1.8.34
+Version: 1.8.36
 Summary: Interactive plotting tool for material science (1D plot) and electrochemistry (GC, CV, dQ/dV, CPC, operando) with batch processing
 Author-email: Tian Dai <tianda@uio.no>
 License: MIT License

{batplot-1.8.34 → batplot-1.8.36}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "batplot"
-version = "1.8.34"
+version = "1.8.36"
 description = "Interactive plotting tool for material science (1D plot) and electrochemistry (GC, CV, dQ/dV, CPC, operando) with batch processing"
 authors = [
     { name = "Tian Dai", email = "tianda@uio.no" }