LS180 — B5 vs Syn — 2026-04-28

LS180
B5-GGFG-Exa
B5-VA-Exa
B5-VC-MMAE
Hu63-GGFG-Exa8
Hu63-VA-Exa
Hu63-VC-MMAE
B5 vs Syn
Published

April 28, 2026

IC50 & Growth Kinetics — LS180 Conjugates

Analysis of PCM_LSConj data: 8 drugs across 2 plates, 6 timepoints.
Two metrics: Fold-D0 and raw Total Cell Area.
IC50 computed two ways: fitted LL.4 plateau midpoint and absolute 50% of untreated by direct interpolation.

Show code
from IPython.display import display, Image as IPImage
import os
import zipfile
import re
import pandas as pd
import numpy as np
from scipy.optimize import curve_fit
import matplotlib
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')

sns.set_style('whitegrid')
plt.rcParams.update({'figure.figsize': (10, 6), 'font.size': 12})

# =====================================================================
#  USER INPUT — change only this section to run a different experiment
# =====================================================================
BASE_DIR     = '/home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics'
DATA_SUBDIR  = '20260428_IC50_ls180' 
CELL_LINE    = 'ls180' # cell line name shown in plot titles
TEST_AB      = 'B5'    # test article antibody prefix
ISO_AB       = 'Syn'   # isotype control antibody prefix
R2_THRESHOLD = 0.5     # minimum R² for a "reliable" LL.4 fit


SCALE_MIN_CONC = 0         # dose-response x-axis lower bound (0 = untreated pseudo-conc)
SCALE_MAX_CONC = None       # None uses all concentrations retained by the reversal filter
SCALE_EXCL_ABS = []         # all retained drugs contribute to y-axis scaling
REVERSAL_FILTER_METRIC = 'TotalCellArea'  # raw metric used to detect fragmentation artefacts
REVERSAL_INCREASE_THRESHOLD = 0.25        # exclude if >25% above the preceding concentration
# =====================================================================

DATA_DIR  = os.path.join(BASE_DIR, DATA_SUBDIR)
PLOT_DIR  = os.path.join(DATA_DIR, 'plots')
os.makedirs(PLOT_DIR, exist_ok=True)
plot_counter = [0]

def save_fig(title=''):
    plot_counter[0] += 1
    fname = os.path.join(PLOT_DIR, f'plot_{plot_counter[0]:02d}.png')
    plt.savefig(fname, dpi=120, bbox_inches='tight')
    plt.close()
    display(IPImage(filename=fname))

# Auto-discover data: prefer pre-extracted CSVs in DATA_DIR, else zip in DATA_DIR
_fname_pat    = re.compile(r'.*_P(?:late)?(\d+)_D(\d+)\.csv', re.IGNORECASE)
csv_data_files = sorted([f for f in os.listdir(DATA_DIR) if _fname_pat.match(f)])
zip_files      = sorted([f for f in os.listdir(DATA_DIR) if f.endswith('.zip')])

if len(csv_data_files) > 0:
    ZIP_PATH    = None
    ZIP_STEM    = DATA_SUBDIR
    EXTRACT_DIR = DATA_DIR
    USE_ZIP     = False
    print(f'No zip needed; using {len(csv_data_files)} pre-extracted CSV(s) in DATA_DIR')
elif len(zip_files) == 1:
    ZIP_PATH    = os.path.join(DATA_DIR, zip_files[0])
    ZIP_STEM    = os.path.splitext(zip_files[0])[0]
    EXTRACT_DIR = DATA_DIR
    USE_ZIP     = True
    print(f'Found zip: {zip_files[0]}')
else:
    raise AssertionError(
        f'No pre-extracted CSVs in {DATA_DIR} and no zip in {BASE_DIR}. '
        f'Found {len(zip_files)} zip(s).'
    )

# Plate layout CSVs live in DATA_DIR
PLATE_LAYOUTS = sorted([f for f in os.listdir(DATA_DIR)
                        if re.match(r'Plate\d+_layout\.csv', f)])
assert len(PLATE_LAYOUTS) >= 1, f'No Plate*_layout.csv found in {DATA_DIR}'

print(f'Data dir : {DATA_DIR}')
print(f'Zip      : {ZIP_PATH}')
print(f'Plates   : {len(PLATE_LAYOUTS)} layout(s) — {PLATE_LAYOUTS}')
print(f'X-axis   : {SCALE_MIN_CONC} – {SCALE_MAX_CONC if SCALE_MAX_CONC is not None else "all retained concentrations"}')
print(f'Excl ABs : {SCALE_EXCL_ABS} (excluded from y-axis range only)')
Found zip: 20260428_IC50_ls180.zip
Data dir : /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/20260428_IC50_ls180
Zip      : /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/20260428_IC50_ls180/20260428_IC50_ls180.zip
Plates   : 3 layout(s) — ['Plate1_layout.csv', 'Plate2_layout.csv', 'Plate3_layout.csv']
X-axis   : 0 – all retained concentrations
Excl ABs : [] (excluded from y-axis range only)

Load Data from Zip

Show code
# ===========================================================================
# 1. Extract zip (if needed) and load confluency data
# ===========================================================================
print('\n=== 1. Extract zip and load confluency data ===')
os.makedirs(EXTRACT_DIR, exist_ok=True)
if USE_ZIP:
    with zipfile.ZipFile(ZIP_PATH, 'r') as z:
        z.extractall(EXTRACT_DIR)

csv_files = sorted([f for f in os.listdir(EXTRACT_DIR) if f.endswith('.csv')])
print(f'{len(csv_files)} CSV files {"extracted" if USE_ZIP else "found"}')

# Flexible pattern: matches _Plate1_D0, _P1_D0, _P1_D07, etc.
fname_pattern = re.compile(r'.*_P(?:late)?(\d+)_D(\d+)\.csv', re.IGNORECASE)

frames = []
seen = set()
for fname in csv_files:
    m = fname_pattern.match(fname)
    if not m:
        continue
    plate_num = int(m.group(1))
    day       = int(m.group(2))
    key = (plate_num, day)
    if key in seen:
        continue
    seen.add(key)
    tmp = pd.read_csv(os.path.join(EXTRACT_DIR, fname), index_col=0)
    tmp.index.name = 'Well'
    tmp = tmp.reset_index()
    tmp['Plate'] = plate_num
    tmp['Day']   = day
    frames.append(tmp)

df_raw = pd.concat(frames, ignore_index=True)
df_raw.rename(columns={'Total cell area': 'TotalCellArea'}, inplace=True)

print(f'Combined raw data: {df_raw.shape[0]} rows  x  {df_raw.shape[1]} cols')
print(f'Plates: {sorted(df_raw.Plate.unique())}   Days: {sorted(df_raw.Day.unique())}')

=== 1. Extract zip and load confluency data ===
37 CSV files extracted
Combined raw data: 1440 rows  x  5 cols
Plates: [np.int64(1), np.int64(2), np.int64(3)]   Days: [np.int64(0), np.int64(1), np.int64(2), np.int64(3), np.int64(4), np.int64(5), np.int64(6), np.int64(7)]

Merge Plate Layouts

Show code
# ===========================================================================
# 2. Load plate layouts and merge
# ===========================================================================
print('\n=== 2. Load plate layouts and merge ===')
layout_frames = []
for lf in PLATE_LAYOUTS:
    plate_num = int(re.search(r'Plate(\d+)', lf).group(1))
    tmp = pd.read_csv(os.path.join(DATA_DIR, lf))
    tmp.rename(columns={'Cell': 'Well'}, inplace=True)
    tmp['Plate'] = plate_num
    layout_frames.append(tmp)
    print(f'Plate {plate_num} drugs: {sorted(tmp.Drug.unique())}')

layouts = pd.concat(layout_frames, ignore_index=True)
print(f'Layout entries: {len(layouts)}  ({len(PLATE_LAYOUTS)} plates)')

df = df_raw.merge(layouts[['Well', 'Drug', 'Conc', 'Plate']],
                  on=['Well', 'Plate'], how='left')

unmatched = df.Drug.isna().sum()
if unmatched > 0:
    print(f'WARNING: {unmatched} wells did not match a layout entry')
else:
    print('All wells matched their layout.')

print(f'Drugs: {sorted(df.Drug.dropna().unique())}')
print(f'Concentrations: {sorted(df.Conc.dropna().unique())}')

# Auto-derive concentration parameters from the data
nonzero_concs = df.loc[df.Conc > 0, 'Conc']
CONC_MIN   = nonzero_concs.min()
CONC_MAX   = nonzero_concs.max()
PSEUDO_CONC = CONC_MIN / 10.0

df['Conc_orig'] = df['Conc'].copy()
df.loc[df.Conc == 0, 'Conc'] = PSEUDO_CONC
print(f'Conc range: {CONC_MIN:.4g} – {CONC_MAX:.4g} nM')
print(f'Conc==0 replaced with pseudo-conc {PSEUDO_CONC:.4g} nM')

=== 2. Load plate layouts and merge ===
Plate 1 drugs: ['B5-GGFG_Exa', 'hu63-GGFG_Exa']
Plate 2 drugs: ['B5-VA-Exa', 'hu63-VA-Exa']
Plate 3 drugs: ['B5-VC-MMAE', 'hu63-VC-MMAE']
Layout entries: 180  (3 plates)
All wells matched their layout.
Drugs: ['B5-GGFG_Exa', 'B5-VA-Exa', 'B5-VC-MMAE', 'hu63-GGFG_Exa', 'hu63-VA-Exa', 'hu63-VC-MMAE']
Concentrations: [np.float64(0.0), np.float64(0.00594702672), np.float64(0.02676162024), np.float64(0.1204272911), np.float64(0.5419228099), np.float64(2.438652644), np.float64(10.9739369), np.float64(49.38271605), np.float64(222.2222222), np.float64(1000.0)]
Conc range: 0.005947 – 1000 nM
Conc==0 replaced with pseudo-conc 0.0005947 nM

Fold-D0 Normalization

Show code
# ===========================================================================
# 3. Fold-D0 normalization
# ===========================================================================
print('\n=== 3. Fold-D0 normalization ===')
d0_confl = df[df.Day == 0][['Plate', 'Well', 'Confluence']].rename(
    columns={'Confluence': 'Confluence_D0'})
d0_tca = df[df.Day == 0][['Plate', 'Well', 'TotalCellArea']].rename(
    columns={'TotalCellArea': 'TCA_D0'})

df = df.merge(d0_confl, on=['Plate', 'Well'], how='left')
df = df.merge(d0_tca, on=['Plate', 'Well'], how='left')
df['FoldD0'] = df['Confluence'] / df['Confluence_D0']
df['FoldD0_TCA'] = df['TotalCellArea'] / df['TCA_D0']

print('All wells have D0 baseline.' if df.Confluence_D0.isna().sum() == 0
      else f'WARNING: {df.Confluence_D0.isna().sum()} rows missing D0')
print(f'Fold-D0 stats by Day:')
print(df.groupby('Day')['FoldD0'].describe().round(3).to_string())

# Drug-by-drug fragmentation filter. Compare mean raw cell area at each
# concentration with the immediately preceding concentration for that drug/day.
_filter_means = (
    df.groupby(['Drug', 'Day', 'Conc'], dropna=False)[REVERSAL_FILTER_METRIC]
    .mean().rename('Reversal_Filter_Mean').reset_index()
    .sort_values(['Drug', 'Day', 'Conc'])
)
_filter_means['Reversal_Previous_Mean'] = (
    _filter_means.groupby(['Drug', 'Day'])['Reversal_Filter_Mean'].shift(1)
)
_prev = _filter_means['Reversal_Previous_Mean']
_curr = _filter_means['Reversal_Filter_Mean']
_filter_means['Reversal_Pct_Increase'] = np.where(
    _prev > 0, (_curr - _prev) / _prev,
    np.where((_prev == 0) & (_curr > 0), np.inf, np.nan)
)
_filter_means['Exclude_25pct_Reversal'] = (
    _filter_means['Reversal_Pct_Increase'] > REVERSAL_INCREASE_THRESHOLD
)
df = df.merge(
    _filter_means[['Drug', 'Day', 'Conc', 'Reversal_Filter_Mean',
                   'Reversal_Previous_Mean', 'Reversal_Pct_Increase',
                   'Exclude_25pct_Reversal']],
    on=['Drug', 'Day', 'Conc'], how='left'
)
df['Exclude_25pct_Reversal'] = df['Exclude_25pct_Reversal'].fillna(False).astype(bool)

excluded_reversals = _filter_means[_filter_means.Exclude_25pct_Reversal].copy()
print(f'\n25% reversal filter metric: {REVERSAL_FILTER_METRIC}')
print(f'Excluded drug/day/concentration groups: {len(excluded_reversals)}')
if not excluded_reversals.empty:
    display(excluded_reversals[['Drug', 'Day', 'Conc', 'Reversal_Previous_Mean',
                                'Reversal_Filter_Mean', 'Reversal_Pct_Increase']])

=== 3. Fold-D0 normalization ===
All wells have D0 baseline.
Fold-D0 stats by Day:
     count   mean    std    min    25%    50%     75%     max
Day                                                          
0    180.0  1.000  0.000  1.000  1.000  1.000   1.000   1.000
1    180.0  1.934  0.189  1.241  1.873  1.963   2.038   2.751
2    180.0  3.050  0.798  1.227  2.626  3.047   3.488   8.638
3    180.0  4.151  1.934  1.193  3.069  3.967   5.116  21.173
4    180.0  6.102  3.824  1.240  3.835  5.772   7.754  31.902
5    180.0  7.093  4.117  1.329  4.207  6.515   9.628  32.034
6    180.0  8.018  4.212  1.445  4.588  7.131  11.400  25.100
7    180.0  9.627  5.419  1.348  5.096  8.315  13.879  19.889

25% reversal filter metric: TotalCellArea
Excluded drug/day/concentration groups: 17
Drug Day Conc Reversal_Previous_Mean Reversal_Filter_Mean Reversal_Pct_Increase
129 B5-VA-Exa 4 1000.000000 2.608274 3.291808 0.262063
259 hu63-GGFG_Exa 1 1000.000000 1.386767 1.854662 0.337400
269 hu63-GGFG_Exa 2 1000.000000 1.738570 5.218360 2.001524
279 hu63-GGFG_Exa 3 1000.000000 2.291862 11.735017 4.120299
288 hu63-GGFG_Exa 4 222.222222 2.694479 5.602735 1.079339
289 hu63-GGFG_Exa 4 1000.000000 5.602735 23.894396 3.264774
298 hu63-GGFG_Exa 5 222.222222 2.885981 5.833107 1.021187
299 hu63-GGFG_Exa 5 1000.000000 5.833107 23.554109 3.038004
308 hu63-GGFG_Exa 6 222.222222 3.091619 4.402998 0.424172
309 hu63-GGFG_Exa 6 1000.000000 4.402998 17.687010 3.017038
319 hu63-GGFG_Exa 7 1000.000000 3.267686 12.893704 2.945821
349 hu63-VA-Exa 2 1000.000000 1.838400 2.495881 0.357637
359 hu63-VA-Exa 3 1000.000000 1.957053 3.611397 0.845324
369 hu63-VA-Exa 4 1000.000000 2.392558 8.297203 2.467922
379 hu63-VA-Exa 5 1000.000000 2.667886 7.777284 1.915148
389 hu63-VA-Exa 6 1000.000000 3.193169 5.887408 0.843751
399 hu63-VA-Exa 7 1000.000000 3.506307 6.096234 0.738648

Drug & Color Setup

Show code
# ===========================================================================
# 4. Drug/color mapping (all 8 drugs together)
# ===========================================================================
all_drugs = sorted(df.Drug.dropna().unique())
fit_days = [d for d in sorted(df.Day.unique()) if d > 0]
all_days = sorted(df.Day.unique())

def _split_ab_lp(name):
    """Split 'AB-LP' on the first dash. LP may contain further dashes."""
    idx = name.find('-')
    return (name[:idx], name[idx+1:]) if idx >= 0 else (name, None)

# Unique AB prefixes and LP suffixes
_all_abs_setup = sorted({_split_ab_lp(d)[0] for d in all_drugs})
_all_lps_setup = sorted({lp for d in all_drugs
                          for lp in [_split_ab_lp(d)[1]] if lp is not None})

# Color  → AB prefix   (same AB = same color across all LPs)
# Style  → LP suffix   (same LP = same linestyle across all ABs)
_ls_cycle = [
    '-',
    '--',
    '-.',
    ':',
    (0, (5, 1)),
    (0, (3, 1, 1, 1)),
    (0, (1, 1)),
    (0, (5, 5)),
    (0, (3, 5, 1, 5)),
    (0, (3, 1, 1, 1, 1, 1)),
]
ab_colors     = dict(zip(_all_abs_setup, sns.color_palette('tab10', len(_all_abs_setup))))
lp_linestyles = {lp: _ls_cycle[i % len(_ls_cycle)]
                 for i, lp in enumerate(_all_lps_setup)}

# Convenience dicts keyed by full drug name (used throughout plotting code)
drug_colors     = {d: ab_colors[_split_ab_lp(d)[0]] for d in all_drugs}
drug_linestyles = {d: lp_linestyles.get(_split_ab_lp(d)[1], '-') for d in all_drugs}

print(f'\n{len(all_drugs)} drugs: {all_drugs}')
print(f'  AB prefixes  ({len(_all_abs_setup)}): {_all_abs_setup}')
print(f'  Linker-payloads ({len(_all_lps_setup)}): {_all_lps_setup}')

6 drugs: ['B5-GGFG_Exa', 'B5-VA-Exa', 'B5-VC-MMAE', 'hu63-GGFG_Exa', 'hu63-VA-Exa', 'hu63-VC-MMAE']
  AB prefixes  (2): ['B5', 'hu63']
  Linker-payloads (3): ['GGFG_Exa', 'VA-Exa', 'VC-MMAE']
Show code
# ===========================================================================
# 4b. Heatmap: TotalCellArea — replicates (96-well grid) + mean (drug × conc)
#     Top panel   : actual plate layout, individual wells (replicates)
#     Bottom panel: mean TotalCellArea per Drug × Concentration
# ===========================================================================
print('\n=== 4b. TotalCellArea heatmaps ===')
import re as _re
from matplotlib.colors import LinearSegmentedColormap

_hm_cmap = LinearSegmentedColormap.from_list(
    'bio_heat', ['green', 'yellow', 'orange', 'red'])

def _parse_well(well):
    """Parse 'A1' → (row 0-7, col 0-11). Returns (None, None) on failure."""
    m = _re.match(r'([A-Ha-h])(\d+)', str(well).strip())
    if not m:
        return None, None
    return ord(m.group(1).upper()) - ord('A'), int(m.group(2)) - 1

_row_labels = list('ABCDEFGH')
_col_labels  = [str(i) for i in range(1, 13)]

# User setting: number of latest non-D0 scan days to show in heatmaps.
# 1 = latest scan only; 2 = latest two scans; etc.
last_n_to_show = 1

_heatmap_days = sorted(fit_days)
_total_heatmap_scans = len(_heatmap_days)
_last_n = int(last_n_to_show)
if _last_n < 1:
    print(f'WARNING: last_n_to_show={last_n_to_show} is less than 1; showing the latest scan only.')
    _last_n = 1
if _last_n > _total_heatmap_scans:
    print(
        f'WARNING: last_n_to_show={last_n_to_show} exceeds total number of scans '
        f'({_total_heatmap_scans}); showing all scans: {_heatmap_days}.'
    )
    _last_n = _total_heatmap_scans
_heatmap_days = _heatmap_days[-_last_n:]
print(f'Heatmap days selected: {_heatmap_days} (last_n_to_show={last_n_to_show})')

for _hm_plate in sorted(df.Plate.unique()):
    for _hm_day in _heatmap_days:
        _hm_sub = df[(df.Plate == _hm_plate) & (df.Day == _hm_day)].copy()
        if _hm_sub.empty:
            continue

        # ── Top: 96-well plate grid (one value per well) ──
        _grid      = np.full((8, 12), np.nan)
        _row_drug  = {}   # row_idx -> drug label
        _col_conc  = {}   # col_idx -> conc label

        for _, wr in _hm_sub.iterrows():
            r, c = _parse_well(wr['Well'])
            if r is None or not (0 <= r < 8 and 0 <= c < 12):
                continue
            _grid[r, c] = wr['TotalCellArea']
            # Collect drug per row and conc per column
            drug_val = wr['Drug'] if pd.notna(wr['Drug']) else ''
            conc_val = wr['Conc_orig'] if pd.notna(wr['Conc_orig']) else np.nan
            if drug_val:
                _row_drug.setdefault(r, set()).add(drug_val)
            if not np.isnan(conc_val):
                _col_conc.setdefault(c, set()).add(conc_val)

        _plate_df = pd.DataFrame(_grid, index=_row_labels, columns=_col_labels)

        # Build secondary axis label lists (one per row/col)
        _sec_row = []
        for ri in range(8):
            drugs = _row_drug.get(ri, set())
            _sec_row.append(', '.join(sorted(drugs)) if drugs else '')

        _sec_col = []
        for ci in range(12):
            concs = _col_conc.get(ci, set())
            if concs:
                v = sorted(concs)[0]
                _sec_col.append('Untreated' if v == 0 else f'{v:g}')
            else:
                _sec_col.append('')

        # ── Bottom: Drug × Conc mean ──
        _hm_pivot = (
            _hm_sub.groupby(['Drug', 'Conc_orig'])['TotalCellArea']
            .mean().unstack()
        )
        _hm_pivot = _hm_pivot.sort_index(axis=0)
        _hm_pivot = _hm_pivot.reindex(sorted(_hm_pivot.columns, reverse=True), axis=1)
        _hm_pivot.columns = [
            'Untreated' if c == 0 else f'{c:g}' for c in _hm_pivot.columns
        ]

        # Shared color scale
        _vmin = np.nanmin([np.nanmin(_grid), _hm_pivot.values.min()])
        _vmax = np.nanmax([np.nanmax(_grid), _hm_pivot.values.max()])

        _n_drug_rows = _hm_pivot.shape[0]
        fig, (ax_top, ax_bot) = plt.subplots(
            2, 1,
            figsize=(16, 10 + _n_drug_rows * 0.5),
            gridspec_kw={'height_ratios': [8, max(2, _n_drug_rows)]},
        )

        # Top: individual wells, formatted to match the averaged heatmap
        sns.heatmap(
            _plate_df, ax=ax_top,
            cmap=_hm_cmap, vmin=_vmin, vmax=_vmax,
            annot=True, fmt='.2f', annot_kws={'size': 7},
            linewidths=0.5, linecolor='white',
            mask=_plate_df.isna(),
            xticklabels=_sec_col,
            yticklabels=_sec_row,
            cbar_kws={'label': 'TotalCellArea (mm²)'},
        )
        ax_top.set_title('Individual wells (replicates)', fontsize=11)
        ax_top.set_xlabel('Concentration (nM)')
        ax_top.set_ylabel('Drug')
        ax_top.tick_params(axis='both', labelsize=10, length=0)
        ax_top.set_xticklabels(_sec_col, fontsize=10, rotation=0)
        ax_top.set_yticklabels(_sec_row, fontsize=10, rotation=0)
        ax_top.grid(False)

        # Bottom: mean per drug × conc
        sns.heatmap(
            _hm_pivot, ax=ax_bot,
            cmap=_hm_cmap, vmin=_vmin, vmax=_vmax,
            annot=True, fmt='.2f',
            linewidths=0.5, linecolor='white',
            cbar_kws={'label': 'TotalCellArea (mm²)'},
        )
        ax_bot.set_title('Mean per Drug × Concentration', fontsize=11)
        ax_bot.set_xlabel('Concentration (nM)')
        ax_bot.set_ylabel('Drug')
        ax_bot.tick_params(axis='both', labelsize=10, length=0)
        ax_bot.set_xticklabels([t.get_text() for t in ax_bot.get_xticklabels()], fontsize=10, rotation=0)
        ax_bot.set_yticklabels([t.get_text() for t in ax_bot.get_yticklabels()], fontsize=10, rotation=0)

        fig.suptitle(
            f'{CELL_LINE} — TotalCellArea — Day {_hm_day} (Plate {_hm_plate})',
            fontsize=13,
        )
        plt.tight_layout()
        save_fig()

=== 4b. TotalCellArea heatmaps ===
Heatmap days selected: [np.int64(7)] (last_n_to_show=1)

Growth Kinetics Plots

Show code
# ===========================================================================
# 5. Growth kinetics plots (per drug, combined plates)
# ===========================================================================
print('\n=== 4. Growth kinetics plots ===')
for drug in all_drugs:
    sub = df[df.Drug == drug].copy()
    concs = sorted(sub.Conc.unique())

    fig, axes = plt.subplots(1, 2, figsize=(16, 5), sharey=False)

    for ax, metric, ylabel in [
        (axes[0], 'FoldD0',        'Fold D0 (Confluence)'),
        (axes[1], 'TotalCellArea', 'Total Cell Area (mm²)'),
    ]:
        for conc in concs:
            csub = sub[sub.Conc == conc]
            means = csub.groupby('Day')[metric].mean()
            sds   = csub.groupby('Day')[metric].std()
            lbl = 'untreated' if conc == PSEUDO_CONC else f'{conc} nM'
            ax.errorbar(means.index, means.values, yerr=sds.values,
                        marker='o', capsize=3, label=lbl)
        ax.set_xlabel('Day')
        ax.set_ylabel(ylabel)
        ax.set_xticks(all_days)
        ax.legend(title='Conc', fontsize=8, title_fontsize=9)

    fig.suptitle(f'{drug} — Growth Kinetics', fontsize=14)
    plt.tight_layout()
    save_fig()

=== 4. Growth kinetics plots ===

LL.4 Model & Interpolation Functions

Show code
# ===========================================================================
# 6. LL.4 fitting functions
# ===========================================================================
print('\n=== 5. LL.4 model ===')

def ll4(x, slope, lower, upper, ec50):
    return lower + (upper - lower) / (1.0 + (x / ec50) ** slope)


def compute_r2(y_obs, y_pred):
    ss_res = np.sum((y_obs - y_pred) ** 2)
    ss_tot = np.sum((y_obs - np.mean(y_obs)) ** 2)
    if ss_tot == 0:
        return 0.0
    return 1.0 - ss_res / ss_tot


def fit_ll4(conc, response, p0=None):
    """Fit LL.4 using the points supplied by the shared analysis filter."""
    conc = np.asarray(conc, dtype=float)
    response = np.asarray(response, dtype=float)
    mask = (conc > 0) & np.isfinite(response)
    conc, response = conc[mask], response[mask]
    if len(conc) < 4 or len(np.unique(conc)) < 3:
        return None, None

    cmin, cmax = conc.min(), conc.max()
    if p0 is None:
        p0 = [1.0, np.min(response), np.max(response), np.median(conc)]

    bounds = (
        [0.01,   -np.inf, -np.inf, cmin * 0.01],
        [np.inf,  np.inf,  np.inf, cmax * 100 ]
    )

    try:
        popt, _ = curve_fit(ll4, conc, response, p0=p0,
                            maxfev=10000, bounds=bounds)
    except Exception:
        return None, None

    y_pred = ll4(conc, *popt)
    r2 = compute_r2(response, y_pred)
    return popt, r2


def fit_ll4_pct_viable(conc, response, upper=100.0):
    """Fit %Viable LL.4 with the untreated-normalized upper plateau fixed at 100%."""
    conc = np.asarray(conc, dtype=float)
    response = np.asarray(response, dtype=float)
    mask = (conc > 0) & np.isfinite(response)
    conc, response = conc[mask], response[mask]
    if len(conc) < 4 or len(np.unique(conc)) < 3:
        return None, None

    cmin, cmax = conc.min(), conc.max()

    def _ll4_fixed_upper(x, slope, lower, ec50):
        return ll4(x, slope, lower, upper, ec50)

    try:
        popt_fixed, _ = curve_fit(
            _ll4_fixed_upper, conc, response,
            p0=[1.0, np.min(response), np.median(conc)],
            bounds=([0.01, -np.inf, cmin * 0.01],
                    [np.inf, np.inf, cmax * 100]),
            maxfev=10000,
        )
    except Exception:
        return None, None

    slope, lower, ec50 = popt_fixed
    popt = np.array([slope, lower, upper, ec50])
    r2 = compute_r2(response, ll4(conc, *popt))
    return popt, r2


def classify_ic50(row):
    if row['R2'] < R2_THRESHOLD:
        return 'poor fit'
    if row['IC50_nM'] < CONC_MIN * 0.5:
        return f'<{CONC_MIN} nM'
    if row['IC50_nM'] > CONC_MAX * 2:
        return f'>{CONC_MAX} nM'
    return f"{row['IC50_nM']:.3g}"


def interpolate_ic50(concs, pct_viable, target=50.0):
    """
    Find concentration where mean %Viable crosses `target` (default 50%).
    Linear interpolation on log10(conc).
    Exclusions are applied before this function is called.
    Returns NaN if the curve never crosses the target.
    """
    means = pct_viable.groupby(concs).mean()
    c = np.array(means.index, dtype=float)
    v = np.array(means.values, dtype=float)
    order = np.argsort(c)
    c, v = c[order], v[order]

    for i in range(len(v) - 1):
        if (v[i] >= target and v[i+1] < target) or \
           (v[i] <= target and v[i+1] > target):
            log_c1, log_c2 = np.log10(c[i]), np.log10(c[i+1])
            frac = (target - v[i]) / (v[i+1] - v[i])
            return 10 ** (log_c1 + frac * (log_c2 - log_c1))

    if v[-1] < target and v[0] >= target:
        return c[-1]
    return np.nan


print(f'LL.4 defined.  R² threshold = {R2_THRESHOLD}')
print('Interpolation IC50 function defined.')
print('Drug/day-specific >25% reversal exclusions active for all IC50 calculations.')

=== 5. LL.4 model ===
LL.4 defined.  R² threshold = 0.5
Interpolation IC50 function defined.
Drug/day-specific >25% reversal exclusions active for all IC50 calculations.

Dose-Response Fitting & Plotting (Both Metrics)

Show code
# ===========================================================================
# 7. Dose-response fitting & plotting — BOTH metrics
# ===========================================================================
METRICS = {
    'FoldD0': {
        'col': 'FoldD0',
        'ylabel_dr': 'Fold D0 (Confluence)',
        'ylabel_pv': '% Viable (Fold-D0 normalized)',
    },
    'TotalCellArea': {
        'col': 'TotalCellArea',
        'ylabel_dr': 'Total Cell Area (mm²)',
        'ylabel_pv': '% Viable (TCA normalized)',
    },
}

all_ic50_tables = {}

# x-axis window derived from user-defined scale bounds
_xlo = PSEUDO_CONC if SCALE_MIN_CONC == 0 else SCALE_MIN_CONC
_xhi = CONC_MAX if SCALE_MAX_CONC is None else SCALE_MAX_CONC


def _analysis_rows(sub_df):
    """Rows allowed to affect scaling, fitted curves, and IC50 calculations."""
    return sub_df[~sub_df['Exclude_25pct_Reversal']].copy()


def _axis_limits(sub_df, col, xlo, xhi, pad=0.10):
    """Y-limits from data within [xlo, xhi], honouring SCALE_EXCL_ABS."""
    vis = _analysis_rows(sub_df[(sub_df['Conc'] >= xlo) & (sub_df['Conc'] <= xhi)])
    if SCALE_EXCL_ABS and 'Drug' in vis.columns:
        vis = vis[~vis['Drug'].str.split('-').str[0].isin(SCALE_EXCL_ABS)]
    if vis.empty:
        return None
    m = vis.groupby('Conc')[col].mean()
    s = vis.groupby('Conc')[col].std().fillna(0)
    lo, hi = (m - s).min(), (m + s).max()
    mg = (hi - lo) * pad if hi > lo else max(abs(hi), abs(lo)) * pad + 0.1
    return lo - mg, hi + mg


for metric_name, minfo in METRICS.items():
    col = minfo['col']
    print(f'\n{"="*60}')
    print(f'=== METRIC: {metric_name} ===')
    print(f'{"="*60}')

    # --- 7a. Dose-response plots (raw metric) ---
    print(f'\n--- Dose-response plots ({metric_name}) ---')
    fit_params_dr = {}
    ic50_dr_records = []

    for drug in all_drugs:
        for day in fit_days:
            sub = df[(df.Drug == drug) & (df.Day == day)].copy()
            sub = sub.dropna(subset=['Conc', col])
            sub = sub[(sub.Conc >= _xlo) & (sub.Conc <= _xhi)]
            sub = _analysis_rows(sub)
            if sub.empty:
                continue
            popt, r2 = fit_ll4(sub.Conc.values, sub[col].values)
            if popt is not None:
                fit_params_dr[(drug, day)] = popt
                ic50_dr_records.append({
                    'Drug': drug, 'Day': day,
                    'IC50_nM': popt[3], 'Slope': popt[0],
                    'Lower': popt[1], 'Upper': popt[2], 'R2': r2,
                })
            else:
                ic50_dr_records.append({
                    'Drug': drug, 'Day': day,
                    'IC50_nM': np.nan, 'Slope': np.nan,
                    'Lower': np.nan, 'Upper': np.nan, 'R2': np.nan,
                })

    for day in fit_days:
        # Pre-scan: y-range across all drugs within the visible x-window
        _all_vis = pd.concat([
            df[(df.Drug == d) & (df.Day == day)].dropna(subset=[col])
            for d in all_drugs
        ], ignore_index=True)
        _ylim_dr = _axis_limits(_all_vis, col, _xlo, _xhi)

        fig, ax = plt.subplots(figsize=(12, 7))
        for drug in all_drugs:
            sub = df[(df.Drug == drug) & (df.Day == day)].copy()
            sub = sub.dropna(subset=[col])
            if sub.empty:
                continue
            means = sub.groupby('Conc')[col].mean()
            sds   = sub.groupby('Conc')[col].std()
            ax.errorbar(means.index, means.values, yerr=sds.values,
                        marker='o', capsize=3, color=drug_colors[drug], label=drug,
                        linestyle='none', linewidth=1.0)
            key = (drug, day)
            if key in fit_params_dr:
                popt = fit_params_dr[key]
                curve_sub = _analysis_rows(sub[(sub.Conc >= _xlo) & (sub.Conc <= _xhi)])
                x_pred = np.geomspace(curve_sub.Conc.min(), curve_sub.Conc.max(), 200)
                y_pred = ll4(x_pred, *popt)
                ax.plot(x_pred, y_pred, color=drug_colors[drug], linewidth=1.5,
                        linestyle=drug_linestyles[drug])

        ax.set_xscale('log')
        if _ylim_dr:
            ax.set_ylim(*_ylim_dr)
        ax.set_xlabel('Concentration (nM, log scale)')
        ax.set_ylabel(minfo['ylabel_dr'])
        ax.set_title(f'Day {day} — Dose Response ({metric_name})')
        ax.legend(fontsize=8, loc='best')
        plt.tight_layout()
        save_fig()

    df_ic50_dr = pd.DataFrame(ic50_dr_records)
    df_ic50_dr['Reliable'] = (
        (df_ic50_dr['R2'] >= R2_THRESHOLD) &
        (df_ic50_dr['IC50_nM'] >= CONC_MIN * 0.5) &
        (df_ic50_dr['IC50_nM'] <= CONC_MAX * 2)
    )
    df_ic50_dr['Status'] = df_ic50_dr.apply(classify_ic50, axis=1)

    print(f'\n  IC50 ({metric_name} direct): {df_ic50_dr.Reliable.sum()} reliable '
          f'of {len(df_ic50_dr)}')

    # --- 7b. %Viable calculation ---
    pv_col = f'PctViable_{metric_name}'
    untx_mean = (
        df[df.Conc_orig == 0]
        .groupby(['Plate', 'Drug', 'Day'])[col]
        .mean()
        .reset_index()
        .rename(columns={col: f'UntxMean_{metric_name}'})
    )
    untx_col = f'UntxMean_{metric_name}'
    df = df.merge(untx_mean, on=['Plate', 'Drug', 'Day'], how='left')
    df[pv_col] = 100.0 * df[col] / df[untx_col]

    # --- 7c. Absolute IC50: interpolated crossing at 50% of untreated ---
    interp_records = []
    for drug in all_drugs:
        for day in fit_days:
            sub = df[(df.Drug == drug) & (df.Day == day)].copy()
            sub = sub.dropna(subset=['Conc', pv_col])
            sub = sub[(sub.Conc >= _xlo) & (sub.Conc <= _xhi)]
            sub = _analysis_rows(sub)
            if sub.empty:
                continue
            ic50_interp = interpolate_ic50(sub.Conc, sub[pv_col], target=50.0)
            interp_records.append({
                'Drug': drug, 'Day': day,
                'Absolute_IC50_nM': ic50_interp, 'IC50_interp': ic50_interp,
            })
    df_interp = pd.DataFrame(interp_records)
    all_ic50_tables[f'{metric_name}_interpolated'] = df_interp

    print(f'\n  Absolute IC50 at 50% untreated ({metric_name}): '
          f'{df_interp.IC50_interp.notna().sum()} of {len(df_interp)} crossed 50%')

    # --- 7d. Fitted IC50: LL.4 midpoint between fitted upper/lower plateaus ---
    fit_params_pv = {}
    ic50_pv_records = []

    for drug in all_drugs:
        for day in fit_days:
            sub = df[(df.Drug == drug) & (df.Day == day)].copy()
            sub = sub.dropna(subset=['Conc', pv_col])
            sub = sub[(sub.Conc >= _xlo) & (sub.Conc <= _xhi)]
            sub = _analysis_rows(sub)
            if sub.empty:
                continue
            popt, r2 = fit_ll4_pct_viable(sub.Conc.values, sub[pv_col].values)
            if popt is not None:
                fit_params_pv[(drug, day)] = popt
                ic50_pv_records.append({
                    'Drug': drug, 'Day': day,
                    'IC50_nM': popt[3], 'Fitted_IC50_nM': popt[3],
                    'Midpoint_Response': (popt[1] + popt[2]) / 2.0,
                    'Slope': popt[0], 'Lower': popt[1], 'Upper': popt[2], 'R2': r2,
                })
            else:
                ic50_pv_records.append({
                    'Drug': drug, 'Day': day,
                    'IC50_nM': np.nan, 'Fitted_IC50_nM': np.nan,
                    'Midpoint_Response': np.nan, 'Slope': np.nan,
                    'Lower': np.nan, 'Upper': np.nan, 'R2': np.nan,
                })

    # --- 7e. %Viable dose-response plots with absolute IC50 markers ---
    for day in fit_days:
        # Pre-scan: y-range across all drugs within the visible x-window
        _all_vis_pv = pd.concat([
            df[(df.Drug == d) & (df.Day == day)].dropna(subset=[pv_col])
            for d in all_drugs
        ], ignore_index=True)
        _ylim_pv = _axis_limits(_all_vis_pv, pv_col, _xlo, _xhi)
        if _ylim_pv:
            _ylim_pv = (0, _ylim_pv[1])

        fig, ax = plt.subplots(figsize=(12, 7))
        _absolute_marker_labeled = False
        for drug in all_drugs:
            sub = df[(df.Drug == drug) & (df.Day == day)].copy()
            sub = sub.dropna(subset=[pv_col])
            if sub.empty:
                continue
            means = sub.groupby('Conc')[pv_col].mean()
            sds   = sub.groupby('Conc')[pv_col].std()
            ax.errorbar(means.index, means.values, yerr=sds.values,
                        marker='o', capsize=3, color=drug_colors[drug], label=drug,
                        linestyle='none', linewidth=1.0)

            # Overlay LL.4 fitted curve if available
            key = (drug, day)
            if key in fit_params_pv:
                popt = fit_params_pv[key]
                curve_sub = _analysis_rows(sub[(sub.Conc >= _xlo) & (sub.Conc <= _xhi)])
                x_pred = np.geomspace(curve_sub.Conc.min(), curve_sub.Conc.max(), 200)
                y_pred = ll4(x_pred, *popt)
                ax.plot(x_pred, y_pred, color=drug_colors[drug], linewidth=1.5,
                        linestyle=drug_linestyles[drug])

            # Mark absolute IC50: concentration crossing 50% of untreated
            row = df_interp[(df_interp.Drug == drug) & (df_interp.Day == day)]
            if not row.empty and pd.notna(row.IC50_interp.values[0]):
                ic50_val = row.IC50_interp.values[0]
                ax.plot(ic50_val, 50, 'D', color=drug_colors[drug],
                        markersize=10, markeredgecolor='black', markeredgewidth=1,
                        label='Absolute IC50 (50% untreated)'
                        if not _absolute_marker_labeled else None,
                        zorder=5)
                _absolute_marker_labeled = True

        ax.set_xscale('log')
        if _ylim_pv:
            ax.set_ylim(*_ylim_pv)
        ax.set_xlabel('Concentration (nM, log scale)')
        ax.set_ylabel(minfo['ylabel_pv'])
        ax.set_title(f'Day {day} — %Viable ({metric_name}) — Absolute IC50 at 50% untreated')
        ax.axhline(50, color='red', ls='--', alpha=0.7, label='50% viable')
        ax.axhline(100, color='grey', ls='--', alpha=0.3)
        ax.legend(fontsize=8, loc='best')
        plt.tight_layout()
        save_fig()

    # --- 7f. %Viable dose-response plots with fitted-midpoint IC50 markers ---
    for day in fit_days:
        _all_vis_pv = pd.concat([
            df[(df.Drug == d) & (df.Day == day)].dropna(subset=[pv_col])
            for d in all_drugs
        ], ignore_index=True)
        _ylim_pv = _axis_limits(_all_vis_pv, pv_col, _xlo, _xhi, pad=0.05)

        fig, ax = plt.subplots(figsize=(12, 7))
        _fitted_marker_labeled = False
        for drug in all_drugs:
            sub = df[(df.Drug == drug) & (df.Day == day)].copy()
            sub = sub.dropna(subset=[pv_col])
            if sub.empty:
                continue
            means = sub.groupby('Conc')[pv_col].mean()
            sds   = sub.groupby('Conc')[pv_col].std()
            ax.errorbar(means.index, means.values, yerr=sds.values,
                        marker='o', capsize=3, color=drug_colors[drug], label=drug,
                        linestyle='none', linewidth=1.0)

            key = (drug, day)
            if key in fit_params_pv:
                popt = fit_params_pv[key]
                curve_sub = _analysis_rows(sub[(sub.Conc >= _xlo) & (sub.Conc <= _xhi)])
                x_pred = np.geomspace(curve_sub.Conc.min(), curve_sub.Conc.max(), 200)
                y_pred = ll4(x_pred, *popt)
                ax.plot(x_pred, y_pred, color=drug_colors[drug], linewidth=1.5,
                        linestyle=drug_linestyles[drug])

                fitted_ic50 = popt[3]
                fitted_midpoint = (popt[1] + popt[2]) / 2.0
                if _xlo <= fitted_ic50 <= _xhi:
                    ax.plot(fitted_ic50, fitted_midpoint, 'D', color=drug_colors[drug],
                            markersize=10, markeredgecolor='black', markeredgewidth=1,
                            label='Fitted IC50 (LL.4 plateau midpoint)'
                            if not _fitted_marker_labeled else None,
                            zorder=5)
                    _fitted_marker_labeled = True

        ax.set_xscale('log')
        if _ylim_pv:
            ax.set_ylim(*_ylim_pv)
        ax.set_xlabel('Concentration (nM, log scale)')
        ax.set_ylabel(minfo['ylabel_pv'])
        ax.set_title(f'Day {day} — %Viable ({metric_name}) — Fitted IC50 at LL.4 plateau midpoint')
        ax.legend(fontsize=8, loc='best')
        plt.tight_layout()
        save_fig()

    df_ic50_pv = pd.DataFrame(ic50_pv_records)
    df_ic50_pv['Reliable'] = (
        (df_ic50_pv['R2'] >= R2_THRESHOLD) &
        (df_ic50_pv['IC50_nM'] >= CONC_MIN * 0.5) &
        (df_ic50_pv['IC50_nM'] <= CONC_MAX * 2)
    )
    df_ic50_pv['Status'] = df_ic50_pv.apply(classify_ic50, axis=1)

    print(f'  Fitted-midpoint IC50 (%Viable {metric_name}): {df_ic50_pv.Reliable.sum()} reliable '
          f'of {len(df_ic50_pv)}')

    all_ic50_tables[f'{metric_name}_direct'] = df_ic50_dr
    all_ic50_tables[f'{metric_name}_pctViable'] = df_ic50_pv

============================================================
=== METRIC: FoldD0 ===
============================================================

--- Dose-response plots (FoldD0) ---


  IC50 (FoldD0 direct): 31 reliable of 42

  Absolute IC50 at 50% untreated (FoldD0): 30 of 42 crossed 50%

  Fitted-midpoint IC50 (%Viable FoldD0): 34 reliable of 42

============================================================
=== METRIC: TotalCellArea ===
============================================================

--- Dose-response plots (TotalCellArea) ---


  IC50 (TotalCellArea direct): 31 reliable of 42

  Absolute IC50 at 50% untreated (TotalCellArea): 29 of 42 crossed 50%

  Fitted-midpoint IC50 (%Viable TotalCellArea): 35 reliable of 42

Trellis: Test vs Isotype by Linker-Payload

Show code
# ===========================================================================
# 7g. Trellis: All Antibodies per Linker-Payload, one subplot per Day
# ===========================================================================
print('\n=== Trellis: dose-response by LP (all antibodies) ===')

# Build lp -> {ab: drug_name} from all drugs
_lp_ab_map = {}
for d in all_drugs:
    ab, lp = _split_ab_lp(d)
    if lp is not None:
        _lp_ab_map.setdefault(lp, {})[ab] = d

_all_lps  = sorted(_lp_ab_map.keys())
_markers  = ['o', 's', '^', 'D', 'v', 'P', '*', 'X', 'h', '<']
print(f'  Linker-payloads: {_all_lps}')
for lp, abmap in sorted(_lp_ab_map.items()):
    print(f'    {lp}: {sorted(abmap.keys())}')

# Derive TEST_AB / ISO_AB matched pairs for section 7g (TI trellis)
_test_drugs  = {lp: ab_drug[TEST_AB] for lp, ab_drug in _lp_ab_map.items() if TEST_AB in ab_drug}
_iso_drugs   = {lp: ab_drug[ISO_AB]  for lp, ab_drug in _lp_ab_map.items() if ISO_AB  in ab_drug}
_matched_lps = sorted(set(_test_drugs) & set(_iso_drugs))

for metric_name, minfo in METRICS.items():
    pv_col = f'PctViable_{metric_name}'

    for lp in _all_lps:
        ab_drug    = _lp_ab_map[lp]
        abs_sorted = sorted(ab_drug.keys())

        # Pre-scan: y-range within SCALE_MIN_CONC–SCALE_MAX_CONC, excluding SCALE_EXCL_ABS
        all_vals = []
        for day in fit_days:
            for ab, drug in ab_drug.items():
                if ab in SCALE_EXCL_ABS:
                    continue
                sub = df[(df.Drug == drug) & (df.Day == day)].dropna(subset=[pv_col])
                vis = sub[(sub.Conc >= _xlo) & (sub.Conc <= _xhi)]
                vis = _analysis_rows(vis)
                if not vis.empty:
                    means = vis.groupby('Conc')[pv_col].mean()
                    sds   = vis.groupby('Conc')[pv_col].std().fillna(0)
                    all_vals.extend((means + sds).tolist())
                    all_vals.extend((means - sds).tolist())
        if not all_vals:
            continue
        y_lo   = min(all_vals)
        y_hi   = max(all_vals)
        margin = (y_hi - y_lo) * 0.08
        ylim   = (y_lo - margin, y_hi + margin)

        ncols = len(fit_days)
        fig, axes = plt.subplots(1, ncols, figsize=(4 * ncols, 5), sharey=True)
        if ncols == 1:
            axes = [axes]

        for ax, day in zip(axes, fit_days):
            for i, ab in enumerate(abs_sorted):
                drug  = ab_drug[ab]
                sub   = df[(df.Drug == drug) & (df.Day == day)].dropna(subset=[pv_col])
                if sub.empty:
                    continue
                means = sub.groupby('Conc')[pv_col].mean()
                sds   = sub.groupby('Conc')[pv_col].std()
                mrkr  = _markers[i % len(_markers)]
                ax.errorbar(means.index, means.values, yerr=sds.values,
                            marker=mrkr, capsize=3, color=drug_colors[drug],
                            label=drug, linestyle='none', linewidth=1.0)
                key = (drug, day)
                if key in fit_params_pv:
                    popt   = fit_params_pv[key]
                    curve_sub = _analysis_rows(sub[(sub.Conc >= _xlo) & (sub.Conc <= _xhi)])
                    x_pred = np.geomspace(curve_sub.Conc.min(), curve_sub.Conc.max(), 200)
                    y_pred = ll4(x_pred, *popt)
                    ax.plot(x_pred, y_pred, color=drug_colors[drug], linewidth=1.5,
                            linestyle=drug_linestyles[drug])

            ax.set_xscale('log')
            ax.set_ylim(ylim)
            ax.set_title(f'Day {day}', fontsize=11)
            ax.set_xlabel('Conc (nM)')
            ax.axhline(50, color='red', ls=':', alpha=0.5)
            ax.axhline(100, color='grey', ls=':', alpha=0.3)
            if ax is axes[0]:
                ax.set_ylabel(minfo['ylabel_pv'])
            ax.legend(fontsize=7, loc='best')

        fig.suptitle(f'{lp} — %Viable ({metric_name})', fontsize=14, y=1.02)
        plt.tight_layout()
        save_fig()

=== Trellis: dose-response by LP (all antibodies) ===
  Linker-payloads: ['GGFG_Exa', 'VA-Exa', 'VC-MMAE']
    GGFG_Exa: ['B5', 'hu63']
    VA-Exa: ['B5', 'hu63']
    VC-MMAE: ['B5', 'hu63']

Trellis: Therapeutic Index by Concentration

Show code
# ===========================================================================
# 7g. Trellis: Therapeutic Index per concentration, per LP x Day
#     TI = %Viable(ISO_AB) / %Viable(each test AB)
# ===========================================================================
print('\n=== Trellis: TI by concentration (all test ABs vs ISO_AB) ===')

for metric_name, minfo in METRICS.items():
    pv_col = f'PctViable_{metric_name}'

    _ti_data    = {}   # (lp, ab, day) -> (conc_array, ti_array)
    _lp_yranges = {}   # lp -> (ymin, ymax)

    for lp in _all_lps:
        ab_drug  = _lp_ab_map[lp]
        if ISO_AB not in ab_drug:
            continue
        iso_drug = ab_drug[ISO_AB]
        test_abs = sorted(ab_drug.keys())  # includes ISO_AB so TI=1 is shown
        if not test_abs:
            continue

        all_ti = []
        for ab in test_abs:
            drug = ab_drug[ab]
            for day in fit_days:
                sub_t = df[(df.Drug == drug)     & (df.Day == day)].dropna(subset=[pv_col])
                sub_i = df[(df.Drug == iso_drug) & (df.Day == day)].dropna(subset=[pv_col])
                sub_t = _analysis_rows(sub_t)
                sub_i = _analysis_rows(sub_i)
                if sub_t.empty or sub_i.empty:
                    continue
                mean_t = sub_t.groupby('Conc')[pv_col].mean()
                mean_i = sub_i.groupby('Conc')[pv_col].mean()
                shared = sorted(set(mean_t.index) & set(mean_i.index))
                if not shared:
                    continue
                concs = np.array(shared)
                ti    = np.array([mean_i[c] / mean_t[c] if mean_t[c] != 0 else np.nan
                                  for c in shared])
                _ti_data[(lp, ab, day)] = (concs, ti)
                all_ti.extend(ti[np.isfinite(ti)].tolist())

        if all_ti:
            _lp_yranges[lp] = (min(all_ti), max(all_ti))

    if not _lp_yranges:
        print(f'  No TI data for {metric_name}')
        continue

    lps_with_ti = [lp for lp in _all_lps if lp in _lp_yranges]
    nrows = len(lps_with_ti)
    ncols = len(fit_days)
    fig, axes = plt.subplots(nrows, ncols,
                             figsize=(3.5 * ncols, 3.5 * nrows),
                             squeeze=False)

    for row, lp in enumerate(lps_with_ti):
        ab_drug  = _lp_ab_map[lp]
        test_abs = sorted(ab_drug.keys())  # includes ISO_AB so TI=1 is shown
        y_lo, y_hi = _lp_yranges[lp]
        margin = (y_hi - y_lo) * 0.1 if y_hi > y_lo else 0.5
        ylim = (y_lo - margin, y_hi + margin)

        for col, day in enumerate(fit_days):
            ax = axes[row][col]
            for i, ab in enumerate(test_abs):
                drug = ab_drug[ab]
                key  = (lp, ab, day)
                if key not in _ti_data:
                    continue
                concs, ti = _ti_data[key]
                mrkr = _markers[i % len(_markers)]
                ax.plot(concs, ti,
                        marker=mrkr, linestyle=drug_linestyles[drug],
                        color=drug_colors[drug], markersize=5, linewidth=1.2,
                        label=drug)

            ax.axhline(1, color='red', ls='--', alpha=0.6)
            ax.set_xscale('log')
            ax.set_ylim(ylim)
            ax.legend(fontsize=6, loc='best')

            if row == 0:
                ax.set_title(f'Day {day}', fontsize=11)
            if col == 0:
                ax.set_ylabel(f'{lp}\nTI ({ISO_AB} / AB)', fontsize=9)
            else:
                ax.set_yticklabels([])
            if row == nrows - 1:
                ax.set_xlabel('Conc (nM)')
            else:
                ax.set_xticklabels([])

    fig.suptitle(f'Therapeutic Index — %Viable ({metric_name})\n'
                 f'TI = {ISO_AB} / each test AB   (red dashed = TI 1)',
                 fontsize=14, y=1.02)
    plt.tight_layout()
    save_fig()

=== Trellis: TI by concentration (all test ABs vs ISO_AB) ===
  No TI data for FoldD0
  No TI data for TotalCellArea

IC50 Summary Tables (Curve Fit)

Show code
# ===========================================================================
# 8. Summary tables — side-by-side comparison
# ===========================================================================
print('\n' + '='*60)
print('=== IC50 SUMMARY — COMPARISON ===')
print('='*60)

for label, df_tbl in all_ic50_tables.items():
    if 'interpolated' in label:
        continue  # handled separately below
    # Reliable IC50 pivot
    pivot = df_tbl[df_tbl.Reliable].pivot_table(
        index='Drug', columns='Day', values='IC50_nM')
    print(f'\n--- {label} — IC50 (nM), reliable only (R²≥{R2_THRESHOLD}, in range) ---')
    if pivot.empty:
        print('  (no reliable fits)')
    else:
        print(pivot.to_string(float_format=lambda x: f'{x:.3g}'))

# --- Absolute IC50 tables (direct crossing at 50% of untreated) ---
print('\n' + '='*60)
print('=== ABSOLUTE IC50 AT 50% OF UNTREATED (no curve fitting) ===')
print('='*60)

for metric_name in METRICS:
    label = f'{metric_name}_interpolated'
    df_interp_tbl = all_ic50_tables[label]
    pivot = df_interp_tbl.pivot_table(
        index='Drug', columns='Day', values='IC50_interp')
    print(f'\n--- {metric_name} — Absolute IC50 (nM) at 50% of untreated ---')
    print(pivot.to_string(float_format=lambda x: f'{x:.3g}'))

# Side-by-side: absolute 50%-untreated crossing vs fitted midpoint (FoldD0)
print('\n--- FoldD0: Absolute 50%-untreated vs fitted-midpoint IC50 ---')
interp = all_ic50_tables['FoldD0_interpolated'][['Drug', 'Day', 'IC50_interp']]
fitted = all_ic50_tables['FoldD0_pctViable']
fitted_rel = fitted[fitted.Reliable][['Drug', 'Day', 'IC50_nM']].rename(
    columns={'IC50_nM': 'IC50_LL4'})
compare = interp.merge(fitted_rel, on=['Drug', 'Day'], how='outer')
compare = compare.dropna(subset=['IC50_interp', 'IC50_LL4'], how='all')
compare['Diff_%'] = ((compare.IC50_interp - compare.IC50_LL4) /
                      compare.IC50_LL4 * 100).round(1)
print(compare.to_string(index=False, float_format=lambda x: f'{x:.3g}'))

============================================================
=== IC50 SUMMARY — COMPARISON ===
============================================================

--- FoldD0_direct — IC50 (nM), reliable only (R²≥0.5, in range) ---
Day             1    2      3      4      5      6      7
Drug                                                     
B5-GGFG_Exa   NaN  NaN 0.0252 0.0181 0.0483 0.0419 0.0523
B5-VA-Exa     NaN 83.9   21.2    112   2.98   1.31  0.327
B5-VC-MMAE    NaN  NaN    NaN  0.125 0.0728  0.068 0.0713
hu63-GGFG_Exa 116  NaN 0.0342  0.145  0.165 0.0869 0.0428
hu63-VA-Exa   NaN 56.5   46.6   13.4   7.03   2.34  0.591
hu63-VC-MMAE  NaN  NaN    NaN 0.0515 0.0639 0.0486  0.046

--- FoldD0_pctViable — IC50 (nM), reliable only (R²≥0.5, in range) ---
Day              2     3     4     5      6      7
Drug                                              
B5-GGFG_Exa   2.24 0.283 0.191 0.215  0.167  0.148
B5-VA-Exa      276  27.1  82.9   2.9   1.64  0.639
B5-VC-MMAE     NaN  3.99 0.402 0.179  0.117 0.0914
hu63-GGFG_Exa 91.5 0.213 0.295 0.284   0.21  0.124
hu63-VA-Exa   42.8  38.7  13.3  5.61   2.33  0.768
hu63-VC-MMAE   NaN  6.06 0.564 0.207 0.0995 0.0674

--- TotalCellArea_direct — IC50 (nM), reliable only (R²≥0.5, in range) ---
Day                  1    2       3      4      5      6      7
Drug                                                           
B5-GGFG_Exa        NaN  NaN   0.017 0.0138 0.0357 0.0342 0.0446
B5-VA-Exa          NaN  107    26.8   29.4   4.51   2.02  0.549
B5-VC-MMAE        97.2  NaN     NaN 0.0415 0.0421 0.0541 0.0638
hu63-GGFG_Exa      NaN  NaN 0.00507    NaN  0.016 0.0138 0.0189
hu63-VA-Exa        NaN 32.6    29.8   13.4   13.6   4.45  0.866
hu63-VC-MMAE  1.03e+03  NaN     NaN  0.203 0.0874 0.0537 0.0487

--- TotalCellArea_pctViable — IC50 (nM), reliable only (R²≥0.5, in range) ---
Day             1     2      3     4     5      6      7
Drug                                                    
B5-GGFG_Exa   NaN 0.359  0.155 0.137  0.17  0.138   0.13
B5-VA-Exa     NaN   116   23.4  32.9  4.14   2.36  0.929
B5-VC-MMAE    NaN   NaN     12  0.44 0.161 0.0983  0.077
hu63-GGFG_Exa NaN 0.866 0.0868 0.162 0.173  0.137 0.0856
hu63-VA-Exa   NaN  37.6   65.9  17.3  9.75   3.57   1.01
hu63-VC-MMAE  428   NaN   49.4  1.22 0.324  0.134 0.0826

============================================================
=== ABSOLUTE IC50 AT 50% OF UNTREATED (no curve fitting) ===
============================================================

--- FoldD0 — Absolute IC50 (nM) at 50% of untreated ---
Day             2    3    4     5     6     7
Drug                                         
B5-GGFG_Exa   NaN  248 11.5  3.61  1.33  0.37
B5-VA-Exa     NaN  NaN 63.2  29.8  16.6   4.7
B5-VC-MMAE    298   30  1.1 0.276 0.161 0.107
hu63-GGFG_Exa NaN  NaN   11   5.1  2.74 0.446
hu63-VA-Exa   NaN  160 36.3  18.8  10.7  3.95
hu63-VC-MMAE  221 16.5 1.62 0.439 0.109 0.079

--- TotalCellArea — Absolute IC50 (nM) at 50% of untreated ---
Day             2    3    4     5     6      7
Drug                                          
B5-GGFG_Exa   NaN  NaN 11.5  4.05  1.83  0.407
B5-VA-Exa     NaN  NaN  152  47.1    25   8.46
B5-VC-MMAE    481 49.1 1.66 0.214 0.114 0.0945
hu63-GGFG_Exa NaN  NaN 5.52     3  1.36  0.291
hu63-VA-Exa   NaN  147 37.1    19  10.8   4.44
hu63-VC-MMAE  300 32.4 3.86 0.807 0.176 0.0939

--- FoldD0: Absolute 50%-untreated vs fitted-midpoint IC50 ---
         Drug  Day  IC50_interp  IC50_LL4   Diff_%
  B5-GGFG_Exa    2          NaN      2.24      NaN
  B5-GGFG_Exa    3          248     0.283 8.75e+04
  B5-GGFG_Exa    4         11.5     0.191 5.92e+03
  B5-GGFG_Exa    5         3.61     0.215 1.58e+03
  B5-GGFG_Exa    6         1.33     0.167      698
  B5-GGFG_Exa    7         0.37     0.148      149
    B5-VA-Exa    2          NaN       276      NaN
    B5-VA-Exa    3          NaN      27.1      NaN
    B5-VA-Exa    4         63.2      82.9    -23.8
    B5-VA-Exa    5         29.8       2.9      926
    B5-VA-Exa    6         16.6      1.64      910
    B5-VA-Exa    7          4.7     0.639      636
   B5-VC-MMAE    2          298       NaN      NaN
   B5-VC-MMAE    3           30      3.99      653
   B5-VC-MMAE    4          1.1     0.402      174
   B5-VC-MMAE    5        0.276     0.179     53.7
   B5-VC-MMAE    6        0.161     0.117     37.5
   B5-VC-MMAE    7        0.107    0.0914     16.6
hu63-GGFG_Exa    2          NaN      91.5      NaN
hu63-GGFG_Exa    3          NaN     0.213      NaN
hu63-GGFG_Exa    4           11     0.295 3.63e+03
hu63-GGFG_Exa    5          5.1     0.284 1.69e+03
hu63-GGFG_Exa    6         2.74      0.21 1.21e+03
hu63-GGFG_Exa    7        0.446     0.124      258
  hu63-VA-Exa    2          NaN      42.8      NaN
  hu63-VA-Exa    3          160      38.7      314
  hu63-VA-Exa    4         36.3      13.3      174
  hu63-VA-Exa    5         18.8      5.61      235
  hu63-VA-Exa    6         10.7      2.33      360
  hu63-VA-Exa    7         3.95     0.768      414
 hu63-VC-MMAE    2          221       NaN      NaN
 hu63-VC-MMAE    3         16.5      6.06      173
 hu63-VC-MMAE    4         1.62     0.564      187
 hu63-VC-MMAE    5        0.439     0.207      112
 hu63-VC-MMAE    6        0.109    0.0995      9.8
 hu63-VC-MMAE    7        0.079    0.0674     17.1

Absolute IC50 Tables

Show code
# ===========================================================================
# 9. IC50 bar plots (reliable, both metrics side by side)
# ===========================================================================
for label, df_tbl in [
    ('FoldD0 %Viable', all_ic50_tables['FoldD0_pctViable']),
    ('TotalCellArea %Viable', all_ic50_tables['TotalCellArea_pctViable']),
]:
    plot_df = df_tbl[df_tbl.Reliable].dropna(subset=['IC50_nM']).copy()
    if plot_df.empty:
        continue
    fig, ax = plt.subplots(figsize=(14, 6))
    drug_order = sorted(plot_df.Drug.unique())
    x = np.arange(len(drug_order))
    day_vals = sorted(plot_df.Day.unique())
    width = 0.8 / max(len(day_vals), 1)
    cmap = sns.color_palette('tab10', len(day_vals))

    for i, day in enumerate(day_vals):
        day_data = plot_df[plot_df.Day == day]
        vals = []
        for drug in drug_order:
            row = day_data[day_data.Drug == drug]
            vals.append(row.IC50_nM.values[0] if len(row) > 0 else np.nan)
        ax.bar(x + i * width, vals, width, label=f'Day {day}', color=cmap[i])

    ax.set_xticks(x + width * (len(day_vals) - 1) / 2)
    ax.set_xticklabels(drug_order, rotation=45, ha='right', fontsize=9)
    ax.set_ylabel('IC50 (nM)')
    ax.set_yscale('log')
    ax.set_title(f'IC50 by Drug and Day — {label}')
    ax.legend()
    plt.tight_layout()
    save_fig()

IC50 Bar Plots

Show code
# ===========================================================================
# 10. Export
# ===========================================================================
print('\n=== 10. Export ===')
out_long = os.path.join(DATA_DIR, f'{ZIP_STEM}_long_foldD0.csv')
df.to_csv(out_long, index=False)
print(f'Saved long data: {out_long}')

for label, df_tbl in all_ic50_tables.items():
    out = os.path.join(DATA_DIR, f'{ZIP_STEM}_IC50_{label}.csv')
    df_tbl.to_csv(out, index=False)
    print(f'Saved: {out}')

print(f'\nTotal plots saved: {plot_counter[0]}')
print('Done.')

=== 10. Export ===
Saved long data: /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/20260428_IC50_ls180/20260428_IC50_ls180_long_foldD0.csv
Saved: /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/20260428_IC50_ls180/20260428_IC50_ls180_IC50_FoldD0_interpolated.csv
Saved: /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/20260428_IC50_ls180/20260428_IC50_ls180_IC50_FoldD0_direct.csv
Saved: /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/20260428_IC50_ls180/20260428_IC50_ls180_IC50_FoldD0_pctViable.csv
Saved: /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/20260428_IC50_ls180/20260428_IC50_ls180_IC50_TotalCellArea_interpolated.csv
Saved: /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/20260428_IC50_ls180/20260428_IC50_ls180_IC50_TotalCellArea_direct.csv
Saved: /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/20260428_IC50_ls180/20260428_IC50_ls180_IC50_TotalCellArea_pctViable.csv

Total plots saved: 59
Done.
Show code
# ===========================================================================
# 11. Therapeutic Windows — Relative IC50 (midpoint between plateaus)
# ===========================================================================
print(f'\n=== 11. Therapeutic Windows ({TEST_AB} vs {ISO_AB}) ===')
print(f'    IC50 = relative IC50: conc at midpoint between untreated & max-dose plateaus')

def parse_drug(name, test_ab, iso_ab):
    """Return (antibody, linker-payload) or (None, None) if not matching."""
    for ab in [test_ab, iso_ab]:
        prefix = ab + '-'
        if name.startswith(prefix):
            return ab, name[len(prefix):]
    return None, None


def relative_ic50(concs, responses):
    """
    Relative IC50: concentration where response = midpoint between
    the untreated plateau (lowest conc) and the max-dose plateau (highest conc).
    Interpolates on log10(conc). Returns (ic50, target_pct, confident).
    confident=False if the curve never monotonically crosses the midpoint.
    """
    means = responses.groupby(concs).mean()
    c = np.array(means.index, dtype=float)
    v = np.array(means.values, dtype=float)
    order = np.argsort(c)
    c, v = c[order], v[order]

    untreated = v[0]
    max_dose  = v[-1]
    target    = (untreated + max_dose) / 2.0
    spread    = abs(untreated - max_dose)

    if spread < 5.0:
        return np.nan, target, False

    for i in range(len(v) - 1):
        if (v[i] >= target >= v[i+1]) or (v[i] <= target <= v[i+1]):
            log_c1, log_c2 = np.log10(max(c[i], 1e-6)), np.log10(max(c[i+1], 1e-6))
            frac = (target - v[i]) / (v[i+1] - v[i])
            ic50 = 10 ** (log_c1 + frac * (log_c2 - log_c1))
            confident = (spread >= 20.0) and (CONC_MIN <= ic50 <= CONC_MAX)
            return ic50, target, confident

    return np.nan, target, False


METRICS_FOR_TI = {
    'FoldD0':        'PctViable_FoldD0',
    'TotalCellArea': 'PctViable_TotalCellArea',
}

all_summary_rows = []

for metric_label, pv_col in METRICS_FOR_TI.items():
    if pv_col not in df.columns:
        print(f'\n  {metric_label}: column {pv_col} not found, skipping.')
        continue

    all_drugs_in_df = sorted(df.Drug.dropna().unique())
    drug_ab = {d: parse_drug(d, TEST_AB, ISO_AB)[0] for d in all_drugs_in_df}
    drug_lp = {d: parse_drug(d, TEST_AB, ISO_AB)[1] for d in all_drugs_in_df}
    test_lps = {drug_lp[d] for d in all_drugs_in_df if drug_ab[d] == TEST_AB}
    iso_lps  = {drug_lp[d] for d in all_drugs_in_df if drug_ab[d] == ISO_AB}
    matched_lps = sorted(test_lps & iso_lps)

    if not matched_lps:
        print(f'\n  {metric_label}: no matched LPs between {TEST_AB} and {ISO_AB}.')
        continue

    days = sorted(df[df.Day.isin(fit_days)].Day.unique())

    print(f'\n{"="*60}')
    print(f'  {metric_label} (%Viable)')
    print(f'  Matched LPs: {matched_lps}')
    print(f'{"="*60}')

    for day in days:
        day_df = df[(df.Day == day)].copy()
        rows = []
        for lp in matched_lps:
            test_drug = f'{TEST_AB}-{lp}'
            iso_drug  = f'{ISO_AB}-{lp}'
            test_sub = day_df[(day_df.Drug == test_drug)].dropna(subset=['Conc', pv_col])
            iso_sub  = day_df[(day_df.Drug == iso_drug)].dropna(subset=['Conc', pv_col])
            test_sub = _analysis_rows(test_sub)
            iso_sub  = _analysis_rows(iso_sub)
            if test_sub.empty or iso_sub.empty:
                continue

            t_ic50, t_target, t_conf = relative_ic50(test_sub.Conc, test_sub[pv_col])
            i_ic50, i_target, i_conf = relative_ic50(iso_sub.Conc, iso_sub[pv_col])

            t_untx = test_sub.groupby('Conc')[pv_col].mean().sort_index().iloc[0]
            t_maxd = test_sub.groupby('Conc')[pv_col].mean().sort_index().iloc[-1]
            i_untx = iso_sub.groupby('Conc')[pv_col].mean().sort_index().iloc[0]
            i_maxd = iso_sub.groupby('Conc')[pv_col].mean().sort_index().iloc[-1]

            ti = i_ic50 / t_ic50 if (not np.isnan(t_ic50) and t_ic50 > 0
                                      and not np.isnan(i_ic50)) else np.nan
            ti_conf = t_conf and i_conf and not np.isnan(ti)

            def fmt(val, conf):
                if np.isnan(val):
                    return 'NA'
                return f'{val:.3g}' if conf else f'{val:.3g}*'

            rows.append({
                'LP': lp,
                f'{TEST_AB} untx→max': f'{t_untx:.0f}→{t_maxd:.0f}%',
                f'{TEST_AB} IC50 (nM)': fmt(t_ic50, t_conf),
                f'{ISO_AB} untx→max': f'{i_untx:.0f}→{i_maxd:.0f}%',
                f'{ISO_AB} IC50 (nM)': fmt(i_ic50, i_conf),
                f'TI ({ISO_AB}/{TEST_AB})': fmt(ti, ti_conf),
            })
            all_summary_rows.append({
                'Method': metric_label, 'Day': day, 'LP': lp,
                f'{TEST_AB}_IC50_nM': t_ic50, f'{TEST_AB}_confident': t_conf,
                f'{TEST_AB}_untreated_%': t_untx, f'{TEST_AB}_maxdose_%': t_maxd,
                f'{ISO_AB}_IC50_nM': i_ic50, f'{ISO_AB}_confident': i_conf,
                f'{ISO_AB}_untreated_%': i_untx, f'{ISO_AB}_maxdose_%': i_maxd,
                'TI': ti, 'TI_confident': ti_conf,
            })

        if not rows:
            print(f'\n  Day {day}: no matched LP pairs with data.')
            continue

        tbl = pd.DataFrame(rows)
        print(f'\n--- {metric_label} — Day {day} ---')
        print(f'    IC50 = conc at midpoint of (untreated, max-dose)')
        print(f'    TI = IC50({ISO_AB}) / IC50({TEST_AB})  ;  * = low confidence')
        print(tbl.to_string(index=False))

        # Grouped bar chart: IC50 by LP
        plot_rows = [r for r in rows
                     if r[f'{TEST_AB} IC50 (nM)'] != 'NA' or r[f'{ISO_AB} IC50 (nM)'] != 'NA']
        if not plot_rows:
            continue
        lps_plot = [r['LP'] for r in plot_rows]

        fig, ax = plt.subplots(figsize=(max(6, len(lps_plot) * 2.5), 5))
        x = np.arange(len(lps_plot))
        width = 0.35
        colors = {TEST_AB: '#2196F3', ISO_AB: '#FF9800'}

        for j, ab in enumerate([TEST_AB, ISO_AB]):
            col_name = f'{ab} IC50 (nM)'
            vals, labels, hatches = [], [], []
            for r in plot_rows:
                raw = r[col_name]
                if raw == 'NA':
                    vals.append(0); labels.append('NA'); hatches.append('//')
                else:
                    v = float(raw.rstrip('*'))
                    vals.append(v)
                    labels.append(raw)
                    hatches.append('//' if raw.endswith('*') else '')
            bars = ax.bar(x + (j - 0.5) * width, vals, width, label=ab,
                          color=colors[ab], alpha=0.85)
            for bar, lbl, hatch in zip(bars, labels, hatches):
                bar.set_hatch(hatch)
                if lbl != 'NA' and bar.get_height() > 0:
                    ax.text(bar.get_x() + bar.get_width() / 2, bar.get_height(),
                            lbl, ha='center', va='bottom', fontsize=9)

        ax.set_xticks(x)
        ax.set_xticklabels(lps_plot, fontsize=11)
        ax.set_ylabel('Relative IC50 (nM)')
        ax.set_title(f'{metric_label} — Day {day}\nRelative IC50 by Linker-Payload  (* = low confidence)',
                     fontsize=13)
        ax.legend()
        ax.set_yscale('log')
        plt.tight_layout()
        save_fig()

        # TI bar chart
        ti_rows = [r for r in plot_rows if r[f'TI ({ISO_AB}/{TEST_AB})'] != 'NA']
        if ti_rows:
            ti_vals = [float(r[f'TI ({ISO_AB}/{TEST_AB})'].rstrip('*')) for r in ti_rows]
            ti_lps  = [r['LP'] for r in ti_rows]
            ti_conf = [not r[f'TI ({ISO_AB}/{TEST_AB})'].endswith('*') for r in ti_rows]

            fig, ax = plt.subplots(figsize=(max(5, len(ti_vals) * 2), 4.5))
            bar_colors = ['#4CAF50' if c else '#FFC107' for c in ti_conf]
            bar_hatches = ['' if c else '//' for c in ti_conf]
            bars = ax.bar(range(len(ti_vals)), ti_vals, color=bar_colors, alpha=0.85)
            for bar, hatch, v, c in zip(bars, bar_hatches, ti_vals, ti_conf):
                bar.set_hatch(hatch)
                lbl = f'{v:.1f}' + ('' if c else '*')
                ax.text(bar.get_x() + bar.get_width() / 2, bar.get_height(),
                        lbl, ha='center', va='bottom', fontsize=10, fontweight='bold')
            ax.axhline(1.0, color='red', linestyle='--', linewidth=1, label='TI = 1')
            ax.set_xticks(range(len(ti_vals)))
            ax.set_xticklabels(ti_lps, fontsize=11)
            ax.set_ylabel(f'Therapeutic Index\nIC50({ISO_AB}) / IC50({TEST_AB})')
            ax.set_title(f'{metric_label} — Day {day}\nTherapeutic Index  (* = low confidence)',
                         fontsize=13)
            ax.legend()
            plt.tight_layout()
            save_fig()

# Export combined summary
if all_summary_rows:
    df_ti_summary = pd.DataFrame(all_summary_rows)
    out = os.path.join(DATA_DIR, f'{ZIP_STEM}_therapeutic_index_{TEST_AB}_vs_{ISO_AB}.csv')
    df_ti_summary.to_csv(out, index=False)
    print(f'\nSaved combined summary: {out}')
    print('\n' + '='*60)
    print('  Combined Therapeutic Index Summary')
    print('='*60)
    print(df_ti_summary.to_string(index=False, float_format=lambda x: f'{x:.3g}'))

=== 11. Therapeutic Windows (B5 vs Syn) ===
    IC50 = relative IC50: conc at midpoint between untreated & max-dose plateaus

  FoldD0: no matched LPs between B5 and Syn.

  TotalCellArea: no matched LPs between B5 and Syn.