SU8686_spheroid — Hu63 vs Syn — 2026-06-05

SU8686_spheroid
79739394_drug_batch_20260605
B5-GGFG-Dxd
Syn-GGFG-Dxd
Hu63 vs Syn
Published

June 5, 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/drug_batch_20260605/'
DATA_SUBDIR  = '20260605_IC50_su8686_spheroid_Hu63_Syn_x_GE' 
CELL_LINE    = 'su8686_spheroid' # cell line name shown in plot titles
TEST_AB      = 'Hu63'    # 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: 20260605_IC50_su8686_spheroid.zip
Data dir : /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/drug_batch_20260605/20260605_IC50_su8686_spheroid_Hu63_Syn_x_GE
Zip      : /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/drug_batch_20260605/20260605_IC50_su8686_spheroid_Hu63_Syn_x_GE/20260605_IC50_su8686_spheroid.zip
Plates   : 1 layout(s) — ['Plate1_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 ===
13 CSV files extracted
Combined raw data: 240 rows  x  5 cols
Plates: [np.int64(1)]   Days: [np.int64(0), np.int64(3), np.int64(5), 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-Dxd', 'Syn-GGFG-Dxd']
Layout entries: 60  (1 plates)
All wells matched their layout.
Drugs: ['B5-GGFG-Dxd', 'Syn-GGFG-Dxd']
Concentrations: [np.float64(0.0), np.float64(0.00446027), np.float64(0.02007121518), np.float64(0.090320468), np.float64(0.4064421074), np.float64(1.828989483), np.float64(8.2304526), np.float64(37.037037037), np.float64(166.6666666), np.float64(750.0)]
Conc range: 0.00446 – 750 nM
Conc==0 replaced with pseudo-conc 0.000446 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     60.0  1.000  0.000  1.000  1.000  1.000  1.000  1.000
3     60.0  1.418  0.112  1.244  1.341  1.411  1.472  1.734
5     60.0  1.413  0.103  1.199  1.338  1.404  1.468  1.729
7     60.0  1.395  0.114  1.095  1.332  1.378  1.468  1.641

25% reversal filter metric: TotalCellArea
Excluded drug/day/concentration groups: 0

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}')

2 drugs: ['B5-GGFG-Dxd', 'Syn-GGFG-Dxd']
  AB prefixes  (2): ['B5', 'Syn']
  Linker-payloads (1): ['GGFG-Dxd']
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): 0 reliable of 6

  Absolute IC50 at 50% untreated (FoldD0): 0 of 6 crossed 50%

  Fitted-midpoint IC50 (%Viable FoldD0): 0 reliable of 6

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

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


  IC50 (TotalCellArea direct): 0 reliable of 6

  Absolute IC50 at 50% untreated (TotalCellArea): 0 of 6 crossed 50%

  Fitted-midpoint IC50 (%Viable TotalCellArea): 0 reliable of 6

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-Dxd']
    GGFG-Dxd: ['B5', 'Syn']

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) ===

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) ---
  (no reliable fits)

--- FoldD0_pctViable — IC50 (nM), reliable only (R²≥0.5, in range) ---
  (no reliable fits)

--- TotalCellArea_direct — IC50 (nM), reliable only (R²≥0.5, in range) ---
  (no reliable fits)

--- TotalCellArea_pctViable — IC50 (nM), reliable only (R²≥0.5, in range) ---
  (no reliable fits)

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

--- FoldD0 — Absolute IC50 (nM) at 50% of untreated ---
Empty DataFrame
Columns: []
Index: []

--- TotalCellArea — Absolute IC50 (nM) at 50% of untreated ---
Empty DataFrame
Columns: []
Index: []

--- FoldD0: Absolute 50%-untreated vs fitted-midpoint IC50 ---
Empty DataFrame
Columns: [Drug, Day, IC50_interp, IC50_LL4, Diff_%]
Index: []

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/drug_batch_20260605/20260605_IC50_su8686_spheroid_Hu63_Syn_x_GE/20260605_IC50_su8686_spheroid_long_foldD0.csv
Saved: /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/drug_batch_20260605/20260605_IC50_su8686_spheroid_Hu63_Syn_x_GE/20260605_IC50_su8686_spheroid_IC50_FoldD0_interpolated.csv
Saved: /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/drug_batch_20260605/20260605_IC50_su8686_spheroid_Hu63_Syn_x_GE/20260605_IC50_su8686_spheroid_IC50_FoldD0_direct.csv
Saved: /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/drug_batch_20260605/20260605_IC50_su8686_spheroid_Hu63_Syn_x_GE/20260605_IC50_su8686_spheroid_IC50_FoldD0_pctViable.csv
Saved: /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/drug_batch_20260605/20260605_IC50_su8686_spheroid_Hu63_Syn_x_GE/20260605_IC50_su8686_spheroid_IC50_TotalCellArea_interpolated.csv
Saved: /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/drug_batch_20260605/20260605_IC50_su8686_spheroid_Hu63_Syn_x_GE/20260605_IC50_su8686_spheroid_IC50_TotalCellArea_direct.csv
Saved: /home/ericchen/gitpcm/2911_RnD/IC50_growth_kinetics/drug_batch_20260605/20260605_IC50_su8686_spheroid_Hu63_Syn_x_GE/20260605_IC50_su8686_spheroid_IC50_TotalCellArea_pctViable.csv

Total plots saved: 25
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 (Hu63 vs Syn) ===
    IC50 = relative IC50: conc at midpoint between untreated & max-dose plateaus

  FoldD0: no matched LPs between Hu63 and Syn.

  TotalCellArea: no matched LPs between Hu63 and Syn.