batplot 1.8.25__tar.gz → 1.8.27__tar.gz

{batplot-1.8.25/batplot.egg-info → batplot-1.8.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: batplot
-Version: 1.8.25
+Version: 1.8.27
 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.25 → batplot-1.8.27}/batplot/__init__.py

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

{batplot-1.8.25 → batplot-1.8.27}/batplot/args.py

@@ -296,18 +296,28 @@ def _print_ec_help() -> None:
         "Use --interactive for styling, colors, line widths, axis scales, etc.\n"
         "GC from .mpt: requires active mass in mg to compute mAh g⁻¹.\n"
         "  batplot --gc file.mpt --mass 6.5 --interactive\n\n"
-        "GC from supported .csv: specific capacity is read directly (no --mass).\n"
-        "  batplot --gc file.csv\n\n"
-        "dQ/dV from supported .csv:\n"
-        "  batplot --dqdv file.csv\n\n"
+        "GC from supported .csv: specific capacity read directly when available; use --mass for\n"
+        "  Neware absolute-capacity files (Cycle Index / Step Index / DataPoint format).\n"
+        "  batplot --gc file.csv\n"
+        "  batplot --gc file.csv --mass 3.52       # Neware absolute-capacity CSV\n\n"
+        "Per-file mass: repeat --mass once per file that needs it, in file order.\n"
+        "  batplot f1.mpt --mass 6.5 f2.csv f3.mpt --mass 7.0 --gc\n"
+        "  batplot f1.csv --mass 3.52 f2.mpt --mass 5.0 --cpc\n"
+        "  # Files without --mass between them use the global --mass value (or none)\n"
+        "  # Single --mass applies to all files: batplot f1.mpt f2.mpt --gc --mass 7.0\n\n"
+        "dQ/dV from supported .csv (pre-calculated column or computed from GC data):\n"
+        "  batplot --dqdv file.csv\n"
+        "  batplot --dqdv file.csv --mass 3.52     # Neware absolute-capacity CSV\n\n"
         "Cyclic voltammetry (CV) from .mpt or .txt: plots voltage vs current for each cycle.\n"
         "  batplot --cv file.mpt\n"
         "  batplot --cv file.txt\n\n"
         "Capacity-per-cycle (CPC) with coulombic efficiency from .csv, .xlsx, or .mpt.\n"
         "Supports multiple files with individual color customization:\n"
-        "  batplot --cpc file.csv                 # Neware CSV\n"
+        "  batplot --cpc file.csv                 # Neware CSV (specific capacity)\n"
+        "  batplot --cpc file.csv --mass 3.52     # Neware absolute-capacity CSV\n"
         "  batplot --cpc file.xlsx                # Landt/Lanhe Excel (Chinese tester)\n"
-        "  batplot --cpc file.mpt --mass 1.2      # Biologic MPT\n"
+        "  batplot --cpc file.mpt --mass 1.2              # Biologic MPT\n"
+        "  batplot file1.csv --mass 3.52 file2.mpt --mass 1.2 --cpc   # Per-file mass\n"
         "  batplot --cpc file1.csv file2.xlsx file3.mpt --mass 1.2 --interactive\n\n"
         "Excel support: Landt/Lanhe (蓝电/蓝河) .xlsx files with Chinese headers:\n"
         "  Expected structure: Row 1=filename, Row 2=headers, Row 3+=data\n"
@@ -457,10 +467,11 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument("--operando", "--contour", action="store_true", dest="operando", help=argparse.SUPPRESS)
     parser.add_argument("--debug", action="store_true", help=argparse.SUPPRESS)
     parser.add_argument("--gc", action="store_true", help=argparse.SUPPRESS)
-    parser.add_argument("--mass", type=float, help=argparse.SUPPRESS)
+    parser.add_argument("--mass", type=float, action='append', help=argparse.SUPPRESS)
     parser.add_argument("--dqdv", action="store_true", help=argparse.SUPPRESS)
     parser.add_argument("--cv", action="store_true", help=argparse.SUPPRESS)
     parser.add_argument("--cpc", action="store_true", help=argparse.SUPPRESS)
+    parser.add_argument("--epc", action="store_true", help=argparse.SUPPRESS)
     parser.add_argument("--pw", nargs=2, type=float, metavar=('V_MIN', 'V_MAX'),
                        help=argparse.SUPPRESS)
     parser.add_argument("--cd", type=float, help=argparse.SUPPRESS)

{batplot-1.8.25 → batplot-1.8.27}/batplot/batch.py

@@ -4,9 +4,11 @@ from __future__ import annotations
 
 import os
 import json
-import matplotlib.cm as cm
-import numpy as np
-import matplotlib.pyplot as plt
+from typing import Tuple, cast
+
+import matplotlib.cm as cm  # type: ignore[import]
+import numpy as np  # type: ignore[import]
+import matplotlib.pyplot as plt  # type: ignore[import]
 
 from .readers import (
     read_gr_file,
@@ -16,8 +18,26 @@ from .readers import (
     read_mpt_file,
     read_ec_csv_file,
     read_ec_csv_dqdv_file,
+    compute_dqdv_numerical,
+    is_cs_b_format,
+    _load_csv_header_and_rows,
     read_biologic_txt_file,
 )
+
+
+def _resolve_mass(mass_arg, file_idx: int = 0):
+    """Return mass (mg) for file at file_idx from a --mass list or single value."""
+    if mass_arg is None:
+        return None
+    if isinstance(mass_arg, (int, float)):
+        return float(mass_arg)
+    if isinstance(mass_arg, list):
+        if len(mass_arg) == 1:
+            return float(mass_arg[0])
+        if file_idx < len(mass_arg):
+            return float(mass_arg[file_idx])
+        return float(mass_arg[-1])
+    return None
 from .utils import _confirm_overwrite, natural_sort_key, ensure_subdirectory
 
 
@@ -886,6 +906,9 @@ def batch_process_ec(directory: str, args):
     elif getattr(args, 'cpc', False):
         mode = 'cpc'
         supported_ext = {'.mpt', '.csv'}
+    elif getattr(args, 'epc', False):
+        mode = 'epc'
+        supported_ext = {'.mpt', '.csv'}
     else:
         print("EC batch mode requires one of: --gc, --cv, --dqdv, or --cpc")
         return
@@ -964,9 +987,10 @@ def batch_process_ec(directory: str, args):
             
             return colors[:n_colors]  # Ensure exact count
     
-    for fname in files:
+    for _batch_file_idx, fname in enumerate(files):
         fpath = os.path.join(directory, fname)
         ext = os.path.splitext(fname)[1].lower()
+        mass_mg = _resolve_mass(getattr(args, 'mass', None), _batch_file_idx)
         
         try:
             fig_b, ax_b = plt.subplots(figsize=(6, 4))
@@ -974,13 +998,14 @@ def batch_process_ec(directory: str, args):
             # ---- GC Mode ----
             if mode == 'gc':
                 if ext == '.mpt':
-                    mass_mg = getattr(args, 'mass', None)
                     if mass_mg is None:
                         print(f"  Skipped {fname}: GC mode (.mpt) requires --mass parameter")
                         plt.close(fig_b)
                         continue
-                    specific_capacity, voltage, cycle_numbers, charge_mask, discharge_mask = \
-                        read_mpt_file(fpath, mode='gc', mass_mg=mass_mg)
+                    specific_capacity, voltage, cycle_numbers, charge_mask, discharge_mask = cast(
+                        Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray],
+                        read_mpt_file(fpath, mode='gc', mass_mg=mass_mg),
+                    )
                     cap_x = specific_capacity
                     x_label = r'Specific Capacity (mAh g$^{-1}$)'
                 elif ext == '.csv':
@@ -1005,14 +1030,19 @@ def batch_process_ec(directory: str, args):
                 
                 # Generate color palette for the number of cycles
                 cycle_colors = get_color_palette(len(cycles_present))
+
+                # Ensure masks are boolean numpy arrays for safe logical operations
+                charge_mask_arr = np.asarray(charge_mask, dtype=bool)
+                discharge_mask_arr = np.asarray(discharge_mask, dtype=bool)
                 
                 for idx, cyc in enumerate(cycles_present):  # Plot all cycles
                     if cycle_numbers is not None:
-                        mask_c = (cyc_int == cyc) & charge_mask
-                        mask_d = (cyc_int == cyc) & discharge_mask
+                        cyc_eq = (cyc_int == cyc)
+                        mask_c = cyc_eq & charge_mask_arr
+                        mask_d = cyc_eq & discharge_mask_arr
                     else:
-                        mask_c = charge_mask
-                        mask_d = discharge_mask
+                        mask_c = charge_mask_arr
+                        mask_d = discharge_mask_arr
                     
                     color = cycle_colors[idx]
                     
@@ -1042,7 +1072,10 @@ def batch_process_ec(directory: str, args):
                 if ext == '.txt':
                     voltage, current, cycles = read_biologic_txt_file(fpath, mode='cv')
                 elif ext == '.mpt':
-                    voltage, current, cycles = read_mpt_file(fpath, mode='cv')
+                    voltage, current, cycles = cast(
+                        Tuple[np.ndarray, np.ndarray, np.ndarray],
+                        read_mpt_file(fpath, mode='cv'),
+                    )
                 else:
                     raise ValueError("CV mode requires .mpt or .txt file")
                 
@@ -1076,10 +1109,39 @@ def batch_process_ec(directory: str, args):
             elif mode == 'dqdv':
                 if ext != '.csv':
                     raise ValueError("dQdV mode requires .csv file")
-                
-                # Read dQdV data with cycle information
-                voltage, dqdv, cycles, charge_mask, discharge_mask, y_label = \
-                    read_ec_csv_dqdv_file(fpath, prefer_specific=True)
+
+                # Try to load pre-calculated dQ/dV columns; fall back to numerical computation
+                _b_dqdv_header = None
+                try:
+                    _b_dqdv_header, _, _ = _load_csv_header_and_rows(fpath)
+                except Exception:
+                    pass
+
+                _b_loaded = False
+                if not _b_loaded:
+                    try:
+                        voltage, dqdv, cycles, charge_mask, discharge_mask, y_label = \
+                            read_ec_csv_dqdv_file(fpath, prefer_specific=True)
+                        _b_loaded = True
+                    except ValueError:
+                        pass
+
+                if not _b_loaded:
+                    _b_gc_cap, _b_gc_volt, _b_gc_cyc, _b_gc_chgm, _b_gc_dchm = \
+                        read_ec_csv_file(fpath, prefer_specific=True)
+                    _b_mass = mass_mg
+                    if _b_dqdv_header is not None:
+                        _b_hdrs = [h.strip().replace('\t', '') for h in _b_dqdv_header]
+                        _b_has_spec = any('Spec. Cap.(mAh/g)' in h for h in _b_hdrs)
+                        _b_has_abs = any(h == 'Capacity(mAh)' for h in _b_hdrs)
+                        if _b_has_abs and not _b_has_spec:
+                            if _b_mass and _b_mass > 0:
+                                _b_gc_cap = _b_gc_cap * (1000.0 / float(_b_mass))
+                            else:
+                                print(f"dQ/dV batch: {fname!r} — pass --mass <mg> for specific dQ/dV.")
+                    voltage, dqdv, cycles, charge_mask, discharge_mask, y_label = \
+                        compute_dqdv_numerical(_b_gc_cap, _b_gc_volt, _b_gc_cyc, _b_gc_chgm, _b_gc_dchm)
+                    print(f"dQ/dV batch: computing numerically from GC data for {fname!r}.")
                 
                 # Process cycles similar to GC mode
                 if cycles is not None and cycles.size > 0:
@@ -1129,48 +1191,91 @@ def batch_process_ec(directory: str, args):
                 legend = ax_b.legend(loc='best', fontsize='small', framealpha=0.8, title='Cycle')
                 legend.get_title().set_fontsize('small')
             
-            # ---- CPC Mode ----
-            elif mode == 'cpc':
+            # ---- CPC / EPC Mode ----
+            elif mode in ('cpc', 'epc'):
                 if ext == '.mpt':
-                    mass_mg = getattr(args, 'mass', None)
                     if mass_mg is None:
-                        print(f"  Skipped {fname}: CPC mode (.mpt) requires --mass parameter")
+                        print(f"  Skipped {fname}: {mode.upper()} mode (.mpt) requires --mass parameter")
                         plt.close(fig_b)
                         continue
-                    cyc_nums, cap_charge, cap_discharge, eff = \
-                        read_mpt_file(fpath, mode='cpc', mass_mg=mass_mg)
-                    x_label = r'Specific Capacity (mAh g$^{-1}$)'
+                    if mode == 'cpc':
+                        cyc_nums, cap_charge, cap_discharge, _eff_dummy = cast(
+                            Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray],
+                            read_mpt_file(fpath, mode='cpc', mass_mg=mass_mg),
+                        )
+                        y_label = r'Specific Capacity (mAh g$^{-1}$)'
+                    else:
+                        cap_x, voltage, cycle_numbers, charge_mask, discharge_mask = cast(
+                            Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray, np.ndarray],
+                            read_mpt_file(fpath, mode='gc', mass_mg=mass_mg),
+                        )
+                        cyc_int_raw = np.array(np.rint(cycle_numbers), dtype=int)
+                        if cyc_int_raw.size:
+                            cycles_present = sorted(int(c) for c in np.unique(cyc_int_raw))
+                            en_charge = []
+                            en_discharge = []
+                            for cyc in cycles_present:
+                                mask_c = (cyc_int_raw == cyc) & charge_mask
+                                mask_d = (cyc_int_raw == cyc) & discharge_mask
+                                if np.count_nonzero(mask_c) >= 2:
+                                    en_c = float(np.trapz(voltage[mask_c], cap_x[mask_c]))
+                                else:
+                                    en_c = 0.0
+                                if np.count_nonzero(mask_d) >= 2:
+                                    en_d = float(np.trapz(voltage[mask_d], cap_x[mask_d]))
+                                else:
+                                    en_d = 0.0
+                                en_charge.append(en_c)
+                                en_discharge.append(en_d)
+                            cyc_nums = np.array(cycles_present)
+                            cap_charge = np.array(en_charge)
+                            cap_discharge = np.array(en_discharge)
+                        else:
+                            cyc_nums = np.array([1.0])
+                            cap_charge = np.array([0.0])
+                            cap_discharge = np.array([0.0])
+                        y_label = r'Specific Energy (mWh g$^{-1}$)'
                 elif ext == '.csv':
                     # For CSV CPC, read as GC-like data
                     cap_x, voltage, cycle_numbers, charge_mask, discharge_mask = \
                         read_ec_csv_file(fpath, prefer_specific=True)
-                    # Plot capacity vs cycle number
                     if cycle_numbers is not None:
                         cyc_int_raw = np.array(np.rint(cycle_numbers), dtype=int)
                         if cyc_int_raw.size:
                             cycles_present = sorted(int(c) for c in np.unique(cyc_int_raw))
-                            # Calculate capacity per cycle
-                            cap_charge = []
-                            cap_discharge = []
+                            cap_charge_list = []
+                            cap_discharge_list = []
                             for cyc in cycles_present:
                                 mask_c = (cyc_int_raw == cyc) & charge_mask
                                 mask_d = (cyc_int_raw == cyc) & discharge_mask
-                                cap_charge.append(np.max(cap_x[mask_c]) if np.any(mask_c) else 0)
-                                cap_discharge.append(np.max(cap_x[mask_d]) if np.any(mask_d) else 0)
+                                if mode == 'cpc':
+                                    val_c = np.max(cap_x[mask_c]) if np.any(mask_c) else 0.0
+                                    val_d = np.max(cap_x[mask_d]) if np.any(mask_d) else 0.0
+                                else:
+                                    if np.count_nonzero(mask_c) >= 2:
+                                        val_c = float(np.trapz(voltage[mask_c], cap_x[mask_c]))
+                                    else:
+                                        val_c = 0.0
+                                    if np.count_nonzero(mask_d) >= 2:
+                                        val_d = float(np.trapz(voltage[mask_d], cap_x[mask_d]))
+                                    else:
+                                        val_d = 0.0
+                                cap_charge_list.append(val_c)
+                                cap_discharge_list.append(val_d)
                             cyc_nums = np.array(cycles_present)
-                            cap_charge = np.array(cap_charge)
-                            cap_discharge = np.array(cap_discharge)
+                            cap_charge = np.array(cap_charge_list)
+                            cap_discharge = np.array(cap_discharge_list)
                         else:
-                            cyc_nums = np.array([1])
-                            cap_charge = np.array([0])
-                            cap_discharge = np.array([0])
+                            cyc_nums = np.array([1.0])
+                            cap_charge = np.array([0.0])
+                            cap_discharge = np.array([0.0])
                     else:
-                        cyc_nums = np.array([1])
-                        cap_charge = np.array([0])
-                        cap_discharge = np.array([0])
-                    x_label = r'Specific Capacity (mAh g$^{-1}$)'
+                        cyc_nums = np.array([1.0])
+                        cap_charge = np.array([0.0])
+                        cap_discharge = np.array([0.0])
+                    y_label = r'Specific Capacity (mAh g$^{-1}$)' if mode == 'cpc' else r'Specific Energy (mWh g$^{-1}$)'
                 else:
-                    raise ValueError(f"Unsupported file type for CPC: {ext}")
+                    raise ValueError(f"Unsupported file type for {mode.upper()}: {ext}")
                 
                 # Plot CPC data
                 ax_b.plot(cyc_nums, cap_charge, 'o-', color='#1f77b4', 
@@ -1178,7 +1283,7 @@ def batch_process_ec(directory: str, args):
                 ax_b.plot(cyc_nums, cap_discharge, 's-', color='#ff7f0e', 
                          linewidth=1.5, markersize=4, label='Discharge', alpha=0.8)
                 ax_b.set_xlabel('Cycle Number')
-                ax_b.set_ylabel(x_label)
+                ax_b.set_ylabel(y_label)
                 ax_b.legend()
                 ax_b.set_title(f"{fname}")