immunology-assays

name	immunology-assays
description	Computational analysis of immunology experimental data. ATAC-seq differential accessibility, immune cell tracking from microscopy, ELISA data processing with 4-parameter logistic fitting, immunohistochemistry quantification, antibody titer analysis, and cell cycle phase duration estimation. For flow cytometry use flow-cytometry-analysis; for scRNA-seq use scanpy.
category	biology
license	MIT license
metadata	{"skill-author":"InkVell Inc."}

Immunology Assays: Experimental Data Analysis

Overview

Immunology Assays provides computational tools for analyzing data from common immunology experiments. This skill covers ATAC-seq differential accessibility analysis (MACS2 peak calling, motif enrichment), ELISA data processing with 4-parameter logistic standard curve fitting, immune cell tracking from time-lapse microscopy, immunohistochemistry (IHC) quantification with H-score calculation, antibody titer determination from serial dilution ELISA, cell cycle phase duration estimation from dual-nucleoside labeling, and multiplex cytokine assay data processing.

When to Use This Skill

• Processing ELISA plate data with standard curve fitting (4PL)
• Quantifying IHC staining intensity (H-score, positive pixel percentage)
• Analyzing ATAC-seq peaks and differential chromatin accessibility
• Tracking immune cell migration from microscopy time-lapse data
• Determining antibody titers from serial dilution experiments
• Estimating cell cycle phase durations from pulse-labeling data
• Processing multiplex cytokine/chemokine assay data (Luminex, MSD)

Related Skills: For flow cytometry analysis use flow-cytometry-analysis. For single-cell RNA-seq use scanpy. For bioimage analysis use bioimage-analysis.

Installation

uv pip install scipy scikit-image opencv-python numpy pandas matplotlib

For ATAC-seq (optional):

# conda install -c bioconda macs2 homer

Quick Start

import numpy as np
from scipy.optimize import curve_fit

# 4-Parameter Logistic (4PL) for ELISA standard curve
def four_pl(x, a, b, c, d):
    """a=min, b=Hill slope, c=EC50, d=max"""
    return d + (a - d) / (1 + (x / c) ** b)

# Standard curve data
concentrations = np.array([0, 15.6, 31.25, 62.5, 125, 250, 500, 1000])
od_values = np.array([0.05, 0.12, 0.22, 0.45, 0.82, 1.35, 1.85, 2.15])

popt, pcov = curve_fit(four_pl, concentrations[1:], od_values[1:],
                       p0=[0.05, 1.0, 200, 2.2], maxfev=10000)
print(f"EC50: {popt[2]:.1f} pg/mL")
print(f"Dynamic range: {popt[0]:.3f} - {popt[3]:.3f} OD")

Core Capabilities

1. ATAC-seq Accessibility Analysis

Peak calling and differential accessibility.

import subprocess
import pandas as pd

def run_macs2_atacseq(bam_path, output_prefix, genome_size='hs'):
    """Call ATAC-seq peaks with MACS2."""
    cmd = [
        'macs2', 'callpeak',
        '-t', bam_path,
        '-f', 'BAMPE',           # Paired-end
        '-g', genome_size,
        '--nomodel',
        '--shift', '-100',
        '--extsize', '200',
        '--broad',               # Broad peaks for open chromatin
        '-n', output_prefix,
        '--outdir', 'macs2_output'
    ]
    result = subprocess.run(cmd, capture_output=True, text=True)
    if result.returncode != 0:
        raise RuntimeError(f"MACS2 failed: {result.stderr}")
    return f'macs2_output/{output_prefix}_peaks.broadPeak'

def parse_broadpeak(peak_file):
    """Parse MACS2 broadPeak output."""
    cols = ['chrom', 'start', 'end', 'name', 'score', 'strand',
            'signal', 'pvalue', 'qvalue']
    df = pd.read_csv(peak_file, sep=, header=, names=cols)
    ()
    ()
     df

 ():
    
     scipy.stats  mannwhitneyu
     statsmodels.stats.multitest  multipletests

    results = []
    groups = ((conditions))
    g1_idx = [i  i, c  (conditions)  c == groups[]]
    g2_idx = [i  i, c  (conditions)  c == groups[]]

     peak  count_matrix.index:
        vals1 = count_matrix.loc[peak].iloc[g1_idx].values
        vals2 = count_matrix.loc[peak].iloc[g2_idx].values

        fc = (vals2.mean() + ) / (vals1.mean() + )
        log2fc = np.log2(fc)

        stat, pval = mannwhitneyu(vals1, vals2, alternative=)
        results.append({: peak, : log2fc, : pval})

    df = pd.DataFrame(results)
    _, df[], _, _ = multipletests(df[], method=)

    sig = df[df[] < padj_threshold]
    ()
    ()
    ()
     df

 ():
    
    cmd = [
        , peak_bed, genome, output_dir,
        , , , , 
    ]
    subprocess.run(cmd, capture_output=, text=, check=)
     output_dir

2. ELISA Data Processing

4-parameter logistic standard curve fitting and unknown interpolation.

import numpy as np
from scipy.optimize import curve_fit
import pandas as pd

def four_pl(x, a, b, c, d):
    """4-Parameter Logistic curve.
    a = minimum asymptote, b = Hill slope, c = EC50, d = maximum asymptote"""
    return d + (a - d) / (1 + (x / c) ** b)

def inverse_four_pl(y, a, b, c, d):
    """Inverse 4PL to interpolate concentration from OD."""
    return c * ((a - d) / (y - d) - 1) ** (1 / b)

def process_elisa_plate(standards, unknowns, blank_od=None):
    """Process ELISA plate with 4PL standard curve.

    Args:
        standards: dict of concentration -> list of OD replicates
        unknowns: dict of sample_name -> list of OD replicates
        blank_od: blank well OD (subtracted from all values)
    """
    # Prepare standard curve data
    conc_list, od_list = [], []
    for conc, ods in sorted(standards.items()):
        for od in ods:
            if conc > 0:  # Skip zero for fitting
                conc_list.append(conc)
                od_list.append(od - (blank_od or 0))

    conc_arr = np.array(conc_list)
    od_arr = np.array(od_list)

    # Fit 4PL
    p0 = [min(od_arr), 1.0, np.median(conc_arr), max(od_arr)]
    popt, pcov = curve_fit(four_pl, conc_arr, od_arr, p0=p0, maxfev=10000)
    a, b, c, d = popt

    
    predicted = four_pl(conc_arr, *popt)
    ss_res = np.((od_arr - predicted) ** )
    ss_tot = np.((od_arr - np.mean(od_arr)) ** )
    r_squared =  - ss_res / ss_tot

    
    lod = inverse_four_pl(a +  * np.std(od_arr[:]), *popt)  a +  * np.std(od_arr[:]) < d  

    ()
    ()
    ()
     lod:
        ()

    
    results = []
     name, ods  unknowns.items():
        od_corrected = [od - (blank_od  )  od  ods]
        concentrations = []
         od  od_corrected:
             a < od < d:  
                conc = inverse_four_pl(od, *popt)
                concentrations.append(conc)
            :
                concentrations.append(np.nan)

        results.append({
            : name,
            : np.mean(od_corrected),
            : np.nanmean(concentrations),
            : np.nanstd(concentrations),
            : (concentrations),
            : (~np.isnan(c)  c  concentrations)
        })

     pd.DataFrame(results), popt, r_squared


standards = {
    : [, ], : [, ], : [, ],
    : [, ], : [, ], : [, ],
    : [, ], : [, ]
}
unknowns = {
    : [, ], : [, ],
    : [, ], : [, ]
}

results, params, r2 = process_elisa_plate(standards, unknowns, blank_od=)
(results[[, , ]])

3. Immune Cell Tracking

Track immune cells in time-lapse microscopy.

import numpy as np
import pandas as pd

def track_immune_cells(tracks_df, pixel_size_um=0.65, frame_interval_min=1):
    """Analyze immune cell migration from tracking data.

    Args:
        tracks_df: DataFrame with columns [particle, frame, x, y]
        pixel_size_um: microns per pixel
        frame_interval_min: minutes between frames
    """
    results = []

    for pid, track in tracks_df.groupby('particle'):
        track = track.sort_values('frame')
        x = track['x'].values * pixel_size_um
        y = track['y'].values * pixel_size_um
        t = track['frame'].values * frame_interval_min

        # Instantaneous velocity
        dx = np.diff(x)
        dy = np.diff(y)
        dt = np.diff(t)
        speeds = np.sqrt(dx**2 + dy**2) / dt

        # Displacement (start to end)
        displacement = np.sqrt((x[-1] - x[0])**2 + (y[-1] - y[0])**2)

        # Total path length
        path_length = np.sum(np.sqrt(dx**2 + dy**2))

        # Confinement ratio (displacement / path_length)
        confinement = displacement / path_length if path_length > 0 else 0

        # Mean squared displacement
        msd_values = []
        for lag in range(1, min((x), )):
            displacements = (x[lag:] - x[:-lag])** + (y[lag:] - y[:-lag])**
            msd_values.append(np.mean(displacements))

        results.append({
            : pid,
            : np.mean(speeds),
            : np.(speeds),
            : displacement,
            : path_length,
            : confinement,
            : t[-] - t[],
            : (track)
        })

    df = pd.DataFrame(results)

    
    df[] = 
    df.loc[df[] > , ] = 
    df.loc[(df[] > ) & (df[] <= ), ] = 

    ()
    ()
    ()
     df

4. IHC Quantification

Quantify immunohistochemistry staining intensity.

import numpy as np
from skimage.color import rgb2hed
import skimage.io

def quantify_ihc(image_path, method='h_score'):
    """Quantify IHC staining using color deconvolution.

    Separates DAB (brown) from hematoxylin (blue) using
    Ruifrok & Johnston color deconvolution.
    """
    image = skimage.io.imread(image_path)

    # Color deconvolution: RGB → HED (Hematoxylin, Eosin, DAB)
    hed = rgb2hed(image)
    dab_channel = hed[:, :, 2]  # DAB is channel 2
    hematoxylin = hed[:, :, 0]

    # Threshold to identify tissue
    tissue_mask = hematoxylin > 0.05

    # DAB intensity classification for H-score
    dab_tissue = dab_channel[tissue_mask]

    # Classify: negative (0), weak (1+), moderate (2+), strong (3+)
    negative = (dab_tissue < 0.1).sum()
    weak = ((dab_tissue >= 0.1) & (dab_tissue < 0.2)).sum()
    moderate = ((dab_tissue >= 0.2) & (dab_tissue < 0.4)).sum()
    strong = (dab_tissue >= 0.4).sum()
    total = len(dab_tissue)

    # H-score: 1*(% weak) + 2*(% moderate) + 3*(% strong)
    h_score = (1 * weak + 2 * moderate + 3 * strong) / total * 100

    # Positive pixel percentage
    positive_pct = 100 * (weak + moderate + strong) / total

    print(f"H-score: {h_score:.1f} (range 0-300)")
    print()
    ()
    ()
    ()

     {
        : h_score,
        : positive_pct,
        :  * negative / total,
        :  * weak / total,
        :  * moderate / total,
        :  * strong / total
    }

5. Antibody Titer Analysis

Determine endpoint titers from serial dilution ELISA.

import numpy as np
from scipy import stats

def calculate_endpoint_titer(dilutions, od_values, cutoff_method='mean_plus_3sd',
                              negative_ods=None):
    """Determine endpoint antibody titer from serial dilution ELISA.

    Args:
        dilutions: list of dilution factors (e.g., [100, 200, 400, ...])
        od_values: list of OD values at each dilution
        negative_ods: list of negative control OD values
    """
    if negative_ods is None:
        cutoff = 0.1  # Default cutoff
    elif cutoff_method == 'mean_plus_3sd':
        cutoff = np.mean(negative_ods) + 3 * np.std(negative_ods)
    elif cutoff_method == 'mean_plus_2sd':
        cutoff = np.mean(negative_ods) + 2 * np.std(negative_ods)
    else:
        cutoff = 0.1

    # Find last dilution above cutoff
    endpoint = None
    for dil, od in zip(dilutions, od_values):
        if od > cutoff:
            endpoint = dil

    if endpoint is None:
        return {'titer': '<' + str(min(dilutions)), 'cutoff': cutoff}

    return {
        'titer': endpoint,
        'log2_titer': np.log2(endpoint),
        'cutoff': cutoff
    }

def ():
    
    log_titers = np.log2([t  t  titers  t > ])
    gmt =  ** np.mean(log_titers)
    ci = stats.t.interval(, df=(log_titers)-,
                          loc=np.mean(log_titers),
                          scale=stats.sem(log_titers))
     {
        : gmt,
        :  ** ci[],
        :  ** ci[],
        : (log_titers)
    }


dilutions = [, , , , , , , ]
sample_ods = [, , , , , , , ]
neg_ods = [, , , ]

result = calculate_endpoint_titer(dilutions, sample_ods, negative_ods=neg_ods)
()
()

6. Cell Cycle Phase Duration

Estimate phase durations from dual-nucleoside pulse labeling.

import numpy as np

def estimate_phase_durations(labeled_fractions, pulse_interval_hours,
                              total_cycle_time=None):
    """Estimate cell cycle phase durations from dual-nucleoside labeling.

    Args:
        labeled_fractions: dict of timepoints -> fraction labeled
        pulse_interval_hours: time between pulses
        total_cycle_time: if known, constrains the estimates
    """
    times = sorted(labeled_fractions.keys())
    fractions = [labeled_fractions[t] for t in times]

    # S-phase duration estimate: fraction labeled at first timepoint * total cycle time
    # If total cycle time unknown, estimate from growth rate
    if total_cycle_time is None:
        # Assume exponential growth, estimate from labeling kinetics
        # Rate of increase in labeled fraction approximates 1/Tc
        if len(fractions) > 1:
            rate = (fractions[-1] - fractions[0]) / (times[-1] - times[0])
            total_cycle_time = 1 / rate if rate > 0 else 24
        else:
            total_cycle_time = 24  # Default

    s_phase = fractions[0] * total_cycle_time
    g2m_phase = pulse_interval_hours  # Time for labeled cells to reach mitosis

    # G1 = total - S - G2/M
    g1_phase = total_cycle_time - s_phase - g2m_phase
    g1_phase = max(g1_phase, 0)

    return {
        'total_cycle': total_cycle_time,
        : g1_phase,
        : s_phase,
        : g2m_phase
    }

7. Cytokine Analysis

Process multiplex cytokine assay data.

import numpy as np
import pandas as pd
from scipy.optimize import curve_fit

def process_multiplex_cytokines(plate_data, analytes, standard_curves):
    """Process multiplex cytokine assay (Luminex/MSD) data.

    Args:
        plate_data: DataFrame with well, sample, analyte, MFI columns
        analytes: list of analyte names
        standard_curves: dict of analyte -> (concentrations, MFI_values)
    """
    def five_pl(x, a, b, c, d, g):
        return d + (a - d) / (1 + (x / c) ** b) ** g

    results = []
    for analyte in analytes:
        # Fit standard curve
        conc, mfi = standard_curves[analyte]
        try:
            popt, _ = curve_fit(five_pl, conc[conc > 0], mfi[conc > 0],
                               p0=[min(mfi), 1, np.median(conc), max(mfi), 1],
                               maxfev=10000)
        except RuntimeError:
            # Fall back to 4PL
            popt = None

        # Interpolate unknowns
        analyte_data = plate_data[plate_data['analyte'] == analyte]
        for _, row in analyte_data.iterrows():
            if popt is not None:
                # Inverse 5PL
                try:
                    from scipy.optimize import brentq
                    conc_val = brentq( x: five_pl(x, *popt) - row[],
                                     , )
                 ValueError:
                    conc_val = np.nan
            :
                conc_val = np.nan

            results.append({
                : row[],
                : analyte,
                : row[],
                : conc_val
            })

     pd.DataFrame(results)

Typical Workflows

Workflow 1: Process ELISA Plate Data with 4PL Standard Curve

standards = {0: [0.05], 15.6: [0.12, 0.13], 31.25: [0.22, 0.24],
             62.5: [0.45, 0.47], 125: [0.82, 0.85], 250: [1.35, 1.38],
             500: [1.85, 1.88], 1000: [2.15, 2.18]}
unknowns = {'Sample_A': [0.68, 0.72], 'Sample_B': [1.45, 1.50]}
results, params, r2 = process_elisa_plate(standards, unknowns, blank_od=0.05)
print(results)

Workflow 2: Quantify IHC Staining Intensity (H-Score)

result = quantify_ihc('ihc_slide.tif')
print(f"H-score: {result['h_score']:.1f}")
print(f"Positive: {result['positive_pct']:.1f}%")

Workflow 3: ATAC-seq Peak Calling and Differential Accessibility

# Call peaks for each condition
peaks_ctrl = run_macs2_atacseq('control.bam', 'control')
peaks_treat = run_macs2_atacseq('treated.bam', 'treated')

# Parse and analyze
ctrl_df = parse_broadpeak(peaks_ctrl)
treat_df = parse_broadpeak(peaks_treat)
print(f"Control peaks: {len(ctrl_df)}, Treatment peaks: {len(treat_df)}")

Best Practices

1. ELISA standard curves — always run standards in duplicate; verify R² > 0.99 for 4PL fit; samples outside curve range should be re-run at appropriate dilutions
2. IHC quantification — use color deconvolution (not simple thresholding) for DAB separation; calibrate thresholds for weak/moderate/strong on control tissue
3. ATAC-seq — use paired-end mode (-f BAMPE); shift reads to account for Tn5 insertion; call narrow peaks for TF footprinting, broad peaks for open chromatin
4. Antibody titers — use geometric mean for group statistics (titers are log-distributed); calculate seroconversion as 4-fold rise
5. Cell tracking — require minimum track length (>10 frames) to exclude artifacts; validate tracking by visual inspection of overlaid tracks
6. Multiplex assays — check for cross-reactivity; flag analytes with CV >15% between replicates

Troubleshooting

Problem: 4PL fit fails to converge Solution: Check that standard curve spans the expected range. Adjust initial parameters (p0). Ensure blank subtraction is correct. Try 5PL for asymmetric curves.

Problem: IHC color deconvolution gives poor separation Solution: Verify image is RGB (not grayscale). Check that staining uses standard DAB/hematoxylin. Adjust HED matrix if using non-standard chromogens.

Problem: ATAC-seq produces too many peaks Solution: Increase -q (q-value) threshold. Filter for peaks with fold enrichment >2. Check for high mitochondrial read fraction (indicates poor quality).

Problem: Antibody titer is below lowest dilution Solution: Use lower starting dilution. Report as "< [lowest dilution]". Check that positive control shows expected titer.

Resources

• ELISA Technical Guide (Thermo Fisher)
• MACS2 Documentation
• HOMER Motif Analysis
• H-score Calculation Guidelines