From 51da2cd75829d6f00213b977503591d49a69c75e Mon Sep 17 00:00:00 2001
From: Lucas Patel <lpatel@ucsd.edu>
Date: Tue, 24 Jun 2025 16:21:50 -0700
Subject: [PATCH] feat: added poc wgs primer validation notebook for posterity

---
 README.md                                     |   2 +-
 .../wgs_primer_validation.ipynb               | 821 ++++++++++++++++++
 2 files changed, 822 insertions(+), 1 deletion(-)
 create mode 100644 notebooks/proof_of_concept/wgs_primer_validation.ipynb

diff --git a/README.md b/README.md
index 3e67822a..ed982985 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@ git clone https://github.com/biocore/kl-metapool.git
 Create a Python3 Conda environment in which to run the package:
 
 ```bash
-conda create --yes -n metapool 'python==3.9' scikit-learn pandas numpy nose pep8 flake8 matplotlib jupyter notebook 'seaborn>=0.7.1' pip openpyxl 'seqtk>=1.4'
+conda create --yes -n metapool -c bioconda 'python==3.9' scikit-learn pandas numpy nose pep8 flake8 matplotlib jupyter notebook 'seaborn>=0.7.1' pip openpyxl 'seqtk>=1.4'
 ```
 
 Activate the Conda environment:
diff --git a/notebooks/proof_of_concept/wgs_primer_validation.ipynb b/notebooks/proof_of_concept/wgs_primer_validation.ipynb
new file mode 100644
index 00000000..29b61845
--- /dev/null
+++ b/notebooks/proof_of_concept/wgs_primer_validation.ipynb
@@ -0,0 +1,821 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "3dc7e964",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#%reload_ext watermark\n",
+    "%matplotlib inline\n",
+    "\n",
+    "import os\n",
+    "import re\n",
+    "import gzip\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from pathlib import Path\n",
+    "import scipy.stats\n",
+    "# from metapool.metapool import *\n",
+    "# from metapool.util import (\n",
+    "#     join_dfs_from_files, extend_sample_accession_df,\n",
+    "#     extend_compression_layout_info, QIITA_STUDY_ID_KEY\n",
+    "# )\n",
+    "\n",
+    "#%watermark -i -v -iv -m -h -p metapool,pandas,matplotlib,seaborn,scipy -u"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ac8d7862",
+   "metadata": {},
+   "source": [
+    "# Knight Lab - FASTQ Comparison Workflow\n",
+    "\n",
+    "### What is it?\n",
+    "\n",
+    "This notebook compares two sequencing runs based on read count distribution and diversity metrics. This is useful for benchmarking two different sequencing runs, primer sets, instruments, etc.\n",
+    "\n",
+    "### How it works\n",
+    "\n",
+    "This workflow compares FASTQ files from two directories by:\n",
+    "1. Loading a plate map to match sample IDs \n",
+    "2. Counting reads per sample from FASTQ files\n",
+    "3. Creating paired comparisons between runs\n",
+    "4. Producing statistical analyses and visualizations\n",
+    "\n",
+    "### Inputs required\n",
+    "\n",
+    "- Two directories containing FASTQ files (`.fastq` or `.fastq.gz`)\n",
+    "- A plate map file with sample information and well positions\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c978a840-d89e-4db8-a152-7769eeb47877",
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "source": [
+    "## Step 1: Define Helper Functions\n",
+    "\n",
+    "The following functions handle file processing and data manipulation:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "8dc8eab7-b017-4223-afd0-b08295470fa6",
+   "metadata": {
+    "tags": [],
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def count_reads_fastq(file_path):\n",
+    "    \"\"\"Count reads in a FASTQ file more efficiently\"\"\"\n",
+    "    try:\n",
+    "        count = 0\n",
+    "        if file_path.endswith(\".gz\"):\n",
+    "            with gzip.open(file_path, \"rt\") as handle:\n",
+    "                for i, _ in enumerate(handle):\n",
+    "                    if i % 4 == 0:  # only count header lines\n",
+    "                        count += 1\n",
+    "        else:\n",
+    "            with open(file_path, \"rt\") as handle:\n",
+    "                for i, _ in enumerate(handle):\n",
+    "                    if i % 4 == 0:\n",
+    "                        count += 1\n",
+    "        return count\n",
+    "    except Exception as e:\n",
+    "        print(f\"Error counting reads in {file_path}: {e}\")\n",
+    "        return 0\n",
+    "\n",
+    "def build_read_count_df(fastq_dir, plate_map=None):\n",
+    "    \"\"\"Build a dataframe of read counts from FASTQ files\"\"\"\n",
+    "    data = []\n",
+    "    fastq_dir_path = Path(fastq_dir)\n",
+    "    \n",
+    "    if not fastq_dir_path.exists():\n",
+    "        print(f\"Warning: Directory {fastq_dir} not found\")\n",
+    "        return pd.DataFrame(columns=[\"SampleID\", \"SampleFile\", \"ReadCount\"])\n",
+    "    \n",
+    "    # parse out present samples via lookup table\n",
+    "    sample_id_lookup = {}\n",
+    "    if plate_map is not None and 'Sample_ID' in plate_map.columns:\n",
+    "        for _, row in plate_map.iterrows():\n",
+    "            sample_id = str(row['Sample_ID'])\n",
+    "            if pd.isna(sample_id) or sample_id is None:\n",
+    "                continue\n",
+    "            \n",
+    "            sample_id_lookup[sample_id] = {\n",
+    "                'sample_id': str(row['SampleID']),\n",
+    "                'well': row['Well'] if 'Well' in row else None\n",
+    "            }\n",
+    "    \n",
+    "    for file_path in fastq_dir_path.glob(\"*.[fF][aA][sS][tT][qQ]*\"):\n",
+    "        fname = file_path.name\n",
+    "        if fname.endswith(\".fastq\") or fname.endswith(\".fastq.gz\"):\n",
+    "            try:\n",
+    "                matched_id = None\n",
+    "                \n",
+    "                # try to match against each Sample_ID in the plate map\n",
+    "                if plate_map is not None:\n",
+    "                    for plate_sample_id in sample_id_lookup:\n",
+    "                        if plate_sample_id in fname:\n",
+    "                            matched_id = sample_id_lookup[plate_sample_id]['sample_id']\n",
+    "                            break\n",
+    "                \n",
+    "                if matched_id is None:\n",
+    "                    print(f\"Warning: Could not match sample ID from {fname}\")\n",
+    "                    continue\n",
+    "                \n",
+    "                read_count = count_reads_fastq(str(file_path))\n",
+    "                \n",
+    "                data.append({\n",
+    "                    \"SampleID\": matched_id, \n",
+    "                    \"SampleFile\": fname, \n",
+    "                    \"ReadCount\": read_count\n",
+    "                })\n",
+    "            except Exception as e:\n",
+    "                print(f\"Error processing {fname}: {e}\")\n",
+    "    \n",
+    "    df = pd.DataFrame(data)\n",
+    "    if not df.empty:\n",
+    "        print(f\"Sample IDs found in FASTQ files: {df['SampleID'].unique()[:10]}...\")\n",
+    "    else:\n",
+    "        print(\"No sample IDs found in FASTQ files\")\n",
+    "    return df\n",
+    "\n",
+    "def load_plate_map(plate_map_path, skiprows=21):\n",
+    "    \"\"\"Load and validate plate map file\"\"\"\n",
+    "    try:\n",
+    "        # try multiple file formats\n",
+    "        try:\n",
+    "            plate_map = pd.read_csv(plate_map_path, skiprows=skiprows)\n",
+    "        except Exception as e1:\n",
+    "            print(f\"Standard CSV loading failed: {e1}\")\n",
+    "            try:\n",
+    "                plate_map = pd.read_csv(plate_map_path, skiprows=skiprows, sep='\\t')\n",
+    "            except Exception as e2:\n",
+    "                print(f\"Tab-delimited loading failed: {e2}\")\n",
+    "                plate_map = pd.read_csv(plate_map_path, sep='\\t')\n",
+    "        \n",
+    "        print(f\"Plate map columns: {plate_map.columns.tolist()}\")\n",
+    "        \n",
+    "        req_cols = [\"Sample_ID\", \"destination_well_384\", \"orig_name\"]\n",
+    "        missing_cols = [col for col in req_cols if col not in plate_map.columns]\n",
+    "        \n",
+    "        if missing_cols:\n",
+    "            print(f\"WARNING: Missing required columns in plate map: {missing_cols}\")\n",
+    "            if \"orig_name\" not in plate_map.columns and \"Sample_ID\" in plate_map.columns:\n",
+    "                # extract numeric portion from Sample_ID as fallback, risky\n",
+    "                plate_map[\"orig_name\"] = plate_map[\"Sample_ID\"].apply(\n",
+    "                    lambda x: re.search(r'(\\d+)', str(x)).group(1) if re.search(r'(\\d+)', str(x)) else x\n",
+    "                )\n",
+    "                print(f\"Created orig_name column from Sample_ID: {plate_map['orig_name'].tolist()[:5]}...\")\n",
+    "        \n",
+    "        if \"orig_name\" in plate_map.columns and \"destination_well_384\" in plate_map.columns:\n",
+    "            plate_map = plate_map.dropna(subset=[\"orig_name\", \"destination_well_384\"])\n",
+    "            \n",
+    "            plate_map = plate_map.rename(columns={\n",
+    "                \"orig_name\": \"SampleID\",\n",
+    "                \"destination_well_384\": \"Well\",\n",
+    "                \"index\": \"Index1\",\n",
+    "                \"index2\": \"Index2\"\n",
+    "            })\n",
+    "        elif \"Sample_ID\" in plate_map.columns and \"destination_well_384\" in plate_map.columns:\n",
+    "            plate_map = plate_map.dropna(subset=[\"Sample_ID\", \"destination_well_384\"])\n",
+    "            \n",
+    "            plate_map = plate_map.rename(columns={\n",
+    "                \"Sample_ID\": \"SampleID\",\n",
+    "                \"destination_well_384\": \"Well\",\n",
+    "                \"index\": \"Index1\",\n",
+    "                \"index2\": \"Index2\"\n",
+    "            })\n",
+    "        else:\n",
+    "            print(\"ERROR: Could not find required columns in plate map\")\n",
+    "            return pd.DataFrame()\n",
+    "        \n",
+    "        print(f\"Sample IDs from plate map: {plate_map['SampleID'].tolist()[:10]}...\")\n",
+    "        return plate_map\n",
+    "    except Exception as e:\n",
+    "        print(f\"Error loading plate map: {e}\")\n",
+    "        return pd.DataFrame()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7888be12-138c-4c00-bb9b-180f523dab20",
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "source": [
+    "## Step 2: Set Input Parameters\n",
+    "\n",
+    "Provide the paths to your two FASTQ directories, plate map file, and output directory:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "992f2448",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# update these paths with your data\n",
+    "fastq_dir_1 = \"/qmounts/qiita_data/per_sample_FASTQ/216584\"\n",
+    "fastq_dir_2 = \"/qmounts/qiita_data/per_sample_FASTQ/216585\"\n",
+    "\n",
+    "plate_map_path = \"TMI_5_CHILD_33_stubtest_iseq_samplesheet_plus_orig_name_dest_well_384 (1).csv\"\n",
+    "output_dir = \"metapool_test\"\n",
+    "\n",
+    "# create output directory\n",
+    "os.makedirs(output_dir, exist_ok=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e35be548-61b6-477b-adbe-1b0951c0b8fd",
+   "metadata": {},
+   "source": [
+    "## Step 3: Define Analysis Functions\n",
+    "\n",
+    "The following functions handle data comparison and analysis."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "6384d9f7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def extract_well_info(df, well_column=\"Well\"):\n",
+    "    \"\"\"Extract row and column information from well IDs\"\"\"\n",
+    "    # validate well format (A1 to P24 for 384-well plate)\n",
+    "    valid_pattern = re.compile(r'^[A-P]([1-9]|1[0-9]|2[0-4])$')\n",
+    "    invalid_rows = df[~df[well_column].str.match(valid_pattern, na=False)]\n",
+    "    \n",
+    "    if not invalid_rows.empty:\n",
+    "        print(f\"WARNING: Found {len(invalid_rows)} rows with invalid well format, skipping:\")\n",
+    "        print(invalid_rows[[\"SampleID\", well_column]].head())\n",
+    "    \n",
+    "    result = df[df[well_column].str.match(valid_pattern, na=False)].copy()\n",
+    "    \n",
+    "    # extract row letter and column number\n",
+    "    result[\"Row\"] = result[well_column].str.extract(r'([A-P])')\n",
+    "    result[\"Column\"] = result[well_column].str.extract(r'(\\d{1,2})')\n",
+    "    result[\"Column\"] = pd.to_numeric(result[\"Column\"], errors='coerce')\n",
+    "    result = result.dropna(subset=[\"Row\", \"Column\"])\n",
+    "    result[\"Column\"] = result[\"Column\"].astype(int)\n",
+    "    \n",
+    "    return result\n",
+    "\n",
+    "def create_paired_comparison(df_1, df_2, plate_map):\n",
+    "    \"\"\"Create a dataframe with proper pairing between first and second datasets\"\"\"\n",
+    "    # check unique sample counts\n",
+    "    plate_unique_samples = plate_map['SampleID'].nunique()\n",
+    "    df_1_unique_samples = df_1['SampleID'].nunique()\n",
+    "    df_2_unique_samples = df_2['SampleID'].nunique()\n",
+    "    \n",
+    "    print(f\"Plate map unique sample IDs: {plate_unique_samples}\")\n",
+    "    print(f\"Dataset 1 unique sample IDs: {df_1_unique_samples}\")\n",
+    "    print(f\"Dataset 2 unique sample IDs: {df_2_unique_samples}\")\n",
+    "    \n",
+    "    # check for sample ID overlap\n",
+    "    samples_1 = set(df_1['SampleID'].unique())\n",
+    "    samples_2 = set(df_2['SampleID'].unique())\n",
+    "    plate_samples = set(plate_map['SampleID'].unique())\n",
+    "    \n",
+    "    overlap_1_plate = len(samples_1.intersection(plate_samples))\n",
+    "    overlap_2_plate = len(samples_2.intersection(plate_samples))\n",
+    "    \n",
+    "    print(f\"\\nSample ID overlap - Dataset1/Plate: {overlap_1_plate}\")\n",
+    "    print(f\"Sample ID overlap - Dataset2/Plate: {overlap_2_plate}\")\n",
+    "    \n",
+    "    # aggregate read counts by SampleID to handle R1/R2 pairs\n",
+    "    df_1_agg = df_1.groupby('SampleID').agg({\n",
+    "        'ReadCount': 'sum',\n",
+    "        'SampleFile': lambda x: ','.join(x)\n",
+    "    }).reset_index()\n",
+    "    \n",
+    "    df_2_agg = df_2.groupby('SampleID').agg({\n",
+    "        'ReadCount': 'sum',\n",
+    "        'SampleFile': lambda x: ','.join(x)\n",
+    "    }).reset_index()\n",
+    "    \n",
+    "    # merge plate map with read counts\n",
+    "    merged_1 = pd.merge(df_1_agg, plate_map[['SampleID', 'Well']], on=\"SampleID\", how=\"inner\")\n",
+    "    merged_1 = merged_1.rename(columns={\n",
+    "        \"ReadCount\": \"ReadCount_1\", \n",
+    "        \"SampleFile\": \"SampleFile_1\"\n",
+    "    })\n",
+    "    \n",
+    "    merged_2 = pd.merge(df_2_agg, plate_map[['SampleID', 'Well']], on=\"SampleID\", how=\"inner\")\n",
+    "    merged_2 = merged_2.rename(columns={\n",
+    "        \"ReadCount\": \"ReadCount_2\", \n",
+    "        \"SampleFile\": \"SampleFile_2\"\n",
+    "    })\n",
+    "    \n",
+    "    # merge both datasets using inner join on SampleID\n",
+    "    merged = pd.merge(\n",
+    "        merged_1[['SampleID', 'Well', 'ReadCount_1', 'SampleFile_1']], \n",
+    "        merged_2[['SampleID', 'ReadCount_2', 'SampleFile_2']], \n",
+    "        on=\"SampleID\", \n",
+    "        how=\"inner\"\n",
+    "    )\n",
+    "    \n",
+    "    # count valid data points\n",
+    "    valid_1 = merged[merged['ReadCount_1'].notna()]['SampleID'].nunique()\n",
+    "    valid_2 = merged[merged['ReadCount_2'].notna()]['SampleID'].nunique()\n",
+    "    valid_both = merged.dropna(subset=[\"ReadCount_1\", \"ReadCount_2\"])['SampleID'].nunique()\n",
+    "    \n",
+    "    print(f\"\\nValid data points - Dataset1: {valid_1}, Dataset2: {valid_2}, Both: {valid_both}\")\n",
+    "    \n",
+    "    # replace zeros with NaN\n",
+    "    merged['ReadCount_1'] = merged['ReadCount_1'].replace(0, np.nan)\n",
+    "    merged['ReadCount_2'] = merged['ReadCount_2'].replace(0, np.nan)\n",
+    "    \n",
+    "    merged[\"FoldChange\"] = merged[\"ReadCount_2\"] / merged[\"ReadCount_1\"]\n",
+    "    \n",
+    "    return merged\n",
+    "\n",
+    "def create_positional_comparison(merged):\n",
+    "    \"\"\"Create comparisons based on plate position (odd/even columns)\"\"\"\n",
+    "    result = merged.copy()\n",
+    "    \n",
+    "    result['Row'] = result['Well'].str[0]  # first character is the row letter\n",
+    "    result['Column'] = result['Well'].str[1:].astype(int)  # rest is the column number\n",
+    "    \n",
+    "    result['Log2FoldChange'] = np.nan\n",
+    "    \n",
+    "    # calculate fold changes for each row in the plate\n",
+    "    for row_letter, group in result.groupby(\"Row\"):\n",
+    "        group = group.sort_values(\"Column\")\n",
+    "        \n",
+    "        for i, row in group.iterrows():\n",
+    "            col = row[\"Column\"]\n",
+    "            \n",
+    "            # odd columns (baseline) get a fold change of 0 (log2(1) = 0)\n",
+    "            if col % 2 == 1:\n",
+    "                result.loc[i, 'Log2FoldChange'] = 0\n",
+    "            # even columns get fold change relative to previous odd column\n",
+    "            else:\n",
+    "                # find matching baseline (previous odd column in same row)\n",
+    "                baseline_col = col - 1\n",
+    "                baseline = group[group[\"Column\"] == baseline_col]\n",
+    "                \n",
+    "                if not baseline.empty and pd.notna(baseline['ReadCount_1'].values[0]) and pd.notna(row['ReadCount_2']):\n",
+    "                    fold_change = np.log2(row['ReadCount_2'] / baseline['ReadCount_1'].values[0])\n",
+    "                    result.loc[i, 'Log2FoldChange'] = fold_change\n",
+    "    \n",
+    "    return result"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "298f8562",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_simple_visualizations(merged, output_dir):\n",
+    "    \"\"\"Create simplified visualizations comparing two datasets\"\"\"\n",
+    "    valid_data = merged.dropna(subset=[\"ReadCount_1\", \"ReadCount_2\"])\n",
+    "    valid_count = valid_data['SampleID'].nunique()\n",
+    "    print(f\"Creating visualizations with {valid_count} valid data points\")\n",
+    "    \n",
+    "    if valid_count == 0:\n",
+    "        print(\"WARNING: No valid data points for visualizations!\")\n",
+    "        return\n",
+    "    \n",
+    "    # ===== SCATTER PLOT =====\n",
+    "    plt.figure(figsize=(8, 8))\n",
+    "    \n",
+    "    # create scatter plot\n",
+    "    plt.scatter(\n",
+    "        valid_data[\"ReadCount_1\"], \n",
+    "        valid_data[\"ReadCount_2\"],\n",
+    "        alpha=0.7, \n",
+    "        s=50, \n",
+    "        edgecolor='black', \n",
+    "        linewidth=0.5,\n",
+    "        color='royalblue'\n",
+    "    )\n",
+    "    \n",
+    "    # add regression line\n",
+    "    sns.regplot(\n",
+    "        x=valid_data[\"ReadCount_1\"], \n",
+    "        y=valid_data[\"ReadCount_2\"],\n",
+    "        scatter=False,\n",
+    "        line_kws={'color': 'red', 'linestyle': '-', 'linewidth': 2}\n",
+    "    )\n",
+    "    \n",
+    "    # set log scales\n",
+    "    plt.xscale(\"log\")\n",
+    "    plt.yscale(\"log\")\n",
+    "    \n",
+    "    # add diagonal identity line (y=x)\n",
+    "    xlim = plt.xlim()\n",
+    "    ylim = plt.ylim()\n",
+    "    min_val = min(xlim[0], ylim[0])\n",
+    "    max_val = max(xlim[1], ylim[1])\n",
+    "    plt.plot([min_val, max_val], [min_val, max_val], 'g-', alpha=0.5, linewidth=1.5, label='y=x')\n",
+    "    plt.xlim(min_val, max_val)\n",
+    "    plt.ylim(min_val, max_val)\n",
+    "    \n",
+    "    # calculate correlations\n",
+    "    pearson_corr, pearson_p = scipy.stats.pearsonr(valid_data[\"ReadCount_1\"], valid_data[\"ReadCount_2\"])\n",
+    "    spearman_corr, spearman_p = scipy.stats.spearmanr(valid_data[\"ReadCount_1\"], valid_data[\"ReadCount_2\"])\n",
+    "    \n",
+    "    # add labels and title\n",
+    "    plt.xlabel(\"Dataset 1 Read Count\")\n",
+    "    plt.ylabel(\"Dataset 2 Read Count\")\n",
+    "    plt.title(f\"Read Count Comparison: Dataset 2 vs Dataset 1 (n={valid_count})\")\n",
+    "    \n",
+    "    # add correlation text\n",
+    "    correlation_text = (\n",
+    "        f\"n = {valid_count}\\n\"\n",
+    "        f\"Pearson r = {pearson_corr:.3f} (p = {pearson_p:.3e})\\n\"\n",
+    "        f\"Spearman ρ = {spearman_corr:.3f} (p = {spearman_p:.3e})\"\n",
+    "    )\n",
+    "    plt.text(0.02, 0.85, correlation_text,\n",
+    "             transform=plt.gca().transAxes, fontsize=10,\n",
+    "             bbox=dict(facecolor='white', alpha=0.8, edgecolor='gray', boxstyle='round,pad=0.5'),\n",
+    "             verticalalignment='top')\n",
+    "    \n",
+    "    plt.grid(True, alpha=0.3)\n",
+    "    plt.tight_layout()\n",
+    "    plt.savefig(f\"{output_dir}/read_comparison_scatter.png\", dpi=300, bbox_inches='tight')\n",
+    "    plt.show()\n",
+    "    plt.close()\n",
+    "    \n",
+    "    # ===== BOXPLOT =====\n",
+    "    plt.figure(figsize=(8, 6))\n",
+    "    \n",
+    "    # convert to log10 for better visualization\n",
+    "    log_data_1 = np.log10(valid_data[\"ReadCount_1\"])\n",
+    "    log_data_2 = np.log10(valid_data[\"ReadCount_2\"])\n",
+    "    \n",
+    "    plot_data = pd.DataFrame({\n",
+    "        'Log10 Read Count': np.concatenate([log_data_1, log_data_2]),\n",
+    "        'Dataset': ['Dataset 1'] * len(log_data_1) + ['Dataset 2'] * len(log_data_2)\n",
+    "    })\n",
+    "    \n",
+    "    sns.boxplot(\n",
+    "        x='Dataset',\n",
+    "        y='Log10 Read Count',\n",
+    "        data=plot_data,\n",
+    "        palette=['lightblue', 'lightcoral']\n",
+    "    )\n",
+    "    \n",
+    "    sns.stripplot(\n",
+    "        x='Dataset',\n",
+    "        y='Log10 Read Count',\n",
+    "        data=plot_data,\n",
+    "        size=4,\n",
+    "        alpha=0.6,\n",
+    "        jitter=True,\n",
+    "        palette=['royalblue', 'tomato']\n",
+    "    )\n",
+    "    \n",
+    "    # statistical test\n",
+    "    t_stat, p_val = scipy.stats.ttest_rel(log_data_1, log_data_2)\n",
+    "    \n",
+    "    plt.title(f\"Read Count Distribution Comparison (n={valid_count})\")\n",
+    "    plt.figtext(0.02, 0.02, f\"Paired t-test: p = {p_val:.3e}, t = {t_stat:.3f}\",\n",
+    "                fontsize=10,\n",
+    "                bbox=dict(facecolor='white', alpha=0.8, edgecolor='gray', boxstyle='round,pad=0.5'))\n",
+    "    \n",
+    "    plt.tight_layout()\n",
+    "    plt.savefig(f\"{output_dir}/read_count_boxplot.png\", dpi=300, bbox_inches='tight')\n",
+    "    plt.show()\n",
+    "    plt.close()\n",
+    "    \n",
+    "    print(\"Visualizations complete.\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4fecb42d",
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "source": [
+    "## Step 4: Load Plate Map and Process FASTQ Files\n",
+    "\n",
+    "Load the plate map and count reads from both FASTQ directories:\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "15eadd17-9836-429f-b94e-ca8c65dd403a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading plate map...\n",
+      "Plate map columns: ['Sample_ID', 'Sample_Name', 'Sample_Plate', 'well_id_384', 'I7_Index_ID', 'index', 'I5_Index_ID', 'index2', 'Sample_Project', 'Well_description', 'Lane', 'orig_name', 'destination_well_384']\n",
+      "Sample IDs from plate map: ['0363173934', '0363185012', '0363157160', 'BLANK.TMI.5.A4', '0363197479', '0363158752', '0363160305', '0363157942', '0363144448', '0363158502']...\n",
+      "Saved processed plate map to metapool_test/processed_plate_map.csv\n",
+      "Building read count dataframes...\n",
+      "Processing first FASTQ directory: /qmounts/qiita_data/per_sample_FASTQ/216584\n",
+      "Sample IDs found in FASTQ files: ['0363156793' '0363196880' '0363174010' '0363144072' '0363182836'\n",
+      " '0363144096' '0363157874' '0363173934' '0363184999' '0363157145']...\n",
+      "Processing second FASTQ directory: /qmounts/qiita_data/per_sample_FASTQ/216585\n",
+      "Sample IDs found in FASTQ files: ['0363158991' '0363197390' '0363157910' '0363156759' '0363158469'\n",
+      " '0363197381' '0363158744' '0363144072' '0363174010' '0363158924']...\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Loading plate map...\")\n",
+    "plate_map = load_plate_map(plate_map_path, skiprows=21)\n",
+    "\n",
+    "if plate_map.empty:\n",
+    "    print(\"ERROR: Failed to load plate map or it contains no valid data\")\n",
+    "\n",
+    "# save a copy of the processed plate map for verification\n",
+    "plate_map.to_csv(f\"{output_dir}/processed_plate_map.csv\", index=False)\n",
+    "print(f\"Saved processed plate map to {output_dir}/processed_plate_map.csv\")\n",
+    "\n",
+    "if 'SampleID' not in plate_map.columns:\n",
+    "    print(\"ERROR: SampleID column not found in processed plate map\")\n",
+    "    print(f\"Available columns: {plate_map.columns.tolist()}\")\n",
+    "\n",
+    "print(\"Building read count dataframes...\")\n",
+    "print(f\"Processing first FASTQ directory: {fastq_dir_1}\")\n",
+    "fastq_df_1 = build_read_count_df(fastq_dir_1, plate_map)\n",
+    "\n",
+    "print(f\"Processing second FASTQ directory: {fastq_dir_2}\")\n",
+    "fastq_df_2 = build_read_count_df(fastq_dir_2, plate_map)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8332dcd1",
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "source": [
+    "## Step 5: Create Paired Comparison and Analysis\n",
+    "\n",
+    "Compare the read counts between the two datasets:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "6f079243-f2c6-40a3-9242-ecc1103d9cb2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Found 74 samples in dataset 1, 74 samples in dataset 2\n",
+      "Creating paired comparison dataset...\n",
+      "Plate map unique sample IDs: 192\n",
+      "Dataset 1 unique sample IDs: 74\n",
+      "Dataset 2 unique sample IDs: 74\n",
+      "\n",
+      "Sample ID overlap - Dataset1/Plate: 74\n",
+      "Sample ID overlap - Dataset2/Plate: 74\n",
+      "\n",
+      "Valid data points - Dataset1: 74, Dataset2: 74, Both: 74\n",
+      "Successfully created paired comparison with 296 valid sample pairs\n"
+     ]
+    }
+   ],
+   "source": [
+    "# save raw read counts\n",
+    "fastq_df_1.to_csv(f\"{output_dir}/dataset_1_read_counts.csv\", index=False)\n",
+    "fastq_df_2.to_csv(f\"{output_dir}/dataset_2_read_counts.csv\", index=False)\n",
+    "\n",
+    "print(f\"Found {fastq_df_1['SampleID'].nunique()} samples in dataset 1, {fastq_df_2['SampleID'].nunique()} samples in dataset 2\")\n",
+    "\n",
+    "if len(fastq_df_1) == 0 or len(fastq_df_2) == 0:\n",
+    "    print(\"ERROR: One or both of the read count datasets is empty\")\n",
+    "    print(f\"  Dataset 1: {len(fastq_df_1)} samples\")\n",
+    "    print(f\"  Dataset 2: {len(fastq_df_2)} samples\")\n",
+    "\n",
+    "print(\"Creating paired comparison dataset...\")\n",
+    "merged = create_paired_comparison(fastq_df_1, fastq_df_2, plate_map)\n",
+    "\n",
+    "# check for valid paired data\n",
+    "valid_data = merged.dropna(subset=[\"ReadCount_1\", \"ReadCount_2\"])\n",
+    "if len(valid_data) == 0:\n",
+    "    print(\"ERROR: No valid paired samples found between the datasets\")\n",
+    "    print(\"This could be due to:\")\n",
+    "    print(\"1. Sample IDs not matching between FASTQ files and plate map\")\n",
+    "    print(\"2. No read counts found for samples in the plate map\")\n",
+    "    print(\"3. No overlap in samples between the two datasets\")\n",
+    "\n",
+    "    # save diagnostic files\n",
+    "    plate_map.to_csv(f\"{output_dir}/plate_map_processed.csv\", index=False)\n",
+    "    fastq_df_1.to_csv(f\"{output_dir}/dataset_1_read_counts.csv\", index=False)\n",
+    "    fastq_df_2.to_csv(f\"{output_dir}/dataset_2_read_counts.csv\", index=False)\n",
+    "    merged.to_csv(f\"{output_dir}/merged_data.csv\", index=False)\n",
+    "\n",
+    "    print(\"\\nDetailed sample ID comparison:\")\n",
+    "    plate_sample_ids = set(plate_map['SampleID'].unique())\n",
+    "    df1_sample_ids = set(fastq_df_1['SampleID'].unique())\n",
+    "    df2_sample_ids = set(fastq_df_2['SampleID'].unique())\n",
+    "\n",
+    "    print(f\"Plate map unique sample IDs: {len(plate_sample_ids)}\")\n",
+    "    print(f\"Dataset 1 unique sample IDs: {len(df1_sample_ids)}\")\n",
+    "    print(f\"Dataset 2 unique sample IDs: {len(df2_sample_ids)}\")\n",
+    "\n",
+    "    print(f\"Overlap between plate map and dataset 1: {len(plate_sample_ids.intersection(df1_sample_ids))}\")\n",
+    "    print(f\"Overlap between plate map and dataset 2: {len(plate_sample_ids.intersection(df2_sample_ids))}\")\n",
+    "    print(f\"Overlap between dataset 1 and 2: {len(df1_sample_ids.intersection(df2_sample_ids))}\")\n",
+    "\n",
+    "    print(f\"Diagnostic files saved to {output_dir}\")\n",
+    "else:\n",
+    "    print(f\"Successfully created paired comparison with {len(valid_data)} valid sample pairs\")\n",
+    "\n",
+    "merged.to_csv(f\"{output_dir}/read_count_comparison.csv\", index=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4b70b2fa-21e9-4229-9100-ba5805e58713",
+   "metadata": {
+    "vscode": {
+     "languageId": "raw"
+    }
+   },
+   "source": [
+    "## Step 6: Create Visualizations\n",
+    "\n",
+    "Generate comparison plots and save results:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "30966e8c-326a-4cbb-8cb8-28d278ac49a2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Creating visualizations...\n",
+      "Creating visualizations with 74 valid data points\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/tmp/ipykernel_41868/249908464.py:84: FutureWarning: \n",
+      "\n",
+      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
+      "\n",
+      "  sns.boxplot(\n",
+      "/tmp/ipykernel_41868/249908464.py:91: FutureWarning: \n",
+      "\n",
+      "Passing `palette` without assigning `hue` is deprecated and will be removed in v0.14.0. Assign the `x` variable to `hue` and set `legend=False` for the same effect.\n",
+      "\n",
+      "  sns.stripplot(\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Visualizations complete.\n",
+      "\n",
+      "Analysis complete! Results saved to 'metapool_test' directory.\n",
+      "Generated files:\n",
+      "  - processed_plate_map.csv: Processed plate map with sample information\n",
+      "  - dataset_1_read_counts.csv: Read counts from first FASTQ directory\n",
+      "  - dataset_2_read_counts.csv: Read counts from second FASTQ directory\n",
+      "  - read_count_comparison.csv: Paired comparison data\n",
+      "  - read_comparison_scatter.png: Scatter plot comparing read counts\n",
+      "  - read_count_boxplot.png: Box plot distribution comparison\n",
+      "\n",
+      "Summary Statistics:\n",
+      "  Total samples in plate map: 192\n",
+      "  Samples found in dataset 1: 74\n",
+      "  Samples found in dataset 2: 74\n",
+      "  Valid paired samples: 296\n",
+      "  Pearson correlation: 0.504 (p = 1.763e-20)\n",
+      "  Dataset 1 mean reads: 21173\n",
+      "  Dataset 2 mean reads: 21107\n",
+      "  Mean fold change (Dataset 2/Dataset 1): 1.07\n",
+      "  Median fold change: 1.00\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Creating visualizations...\")\n",
+    "create_simple_visualizations(merged, output_dir)\n",
+    "\n",
+    "print(f\"\\nAnalysis complete! Results saved to '{output_dir}' directory.\")\n",
+    "print(f\"Generated files:\")\n",
+    "print(f\"  - processed_plate_map.csv: Processed plate map with sample information\")\n",
+    "print(f\"  - dataset_1_read_counts.csv: Read counts from first FASTQ directory\")\n",
+    "print(f\"  - dataset_2_read_counts.csv: Read counts from second FASTQ directory\")\n",
+    "print(f\"  - read_count_comparison.csv: Paired comparison data\")\n",
+    "print(f\"  - read_comparison_scatter.png: Scatter plot comparing read counts\")\n",
+    "print(f\"  - read_count_boxplot.png: Box plot distribution comparison\")\n",
+    "\n",
+    "# print summary statistics\n",
+    "valid_data = merged.dropna(subset=[\"ReadCount_1\", \"ReadCount_2\"])\n",
+    "if len(valid_data) > 0:\n",
+    "    print(f\"\\nSummary Statistics:\")\n",
+    "    print(f\"  Total samples in plate map: {plate_map['SampleID'].nunique()}\")\n",
+    "    print(f\"  Samples found in dataset 1: {fastq_df_1['SampleID'].nunique()}\")\n",
+    "    print(f\"  Samples found in dataset 2: {fastq_df_2['SampleID'].nunique()}\")\n",
+    "    print(f\"  Valid paired samples: {len(valid_data)}\")\n",
+    "    \n",
+    "    pearson_corr, pearson_p = scipy.stats.pearsonr(valid_data[\"ReadCount_1\"], valid_data[\"ReadCount_2\"])\n",
+    "    print(f\"  Pearson correlation: {pearson_corr:.3f} (p = {pearson_p:.3e})\")\n",
+    "    \n",
+    "    # basic read count statistics\n",
+    "    print(f\"  Dataset 1 mean reads: {valid_data['ReadCount_1'].mean():.0f}\")\n",
+    "    print(f\"  Dataset 2 mean reads: {valid_data['ReadCount_2'].mean():.0f}\")\n",
+    "    \n",
+    "    fold_change = valid_data[\"ReadCount_2\"] / valid_data[\"ReadCount_1\"]\n",
+    "    print(f\"  Mean fold change (Dataset 2/Dataset 1): {fold_change.mean():.2f}\")\n",
+    "    print(f\"  Median fold change: {fold_change.median():.2f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "080cdc45-48fc-470b-9bed-852cac0dd7a2",
+   "metadata": {},
+   "source": [
+    "## Workflow Complete\n",
+    "\n",
+    "The FASTQ comparison workflow is now complete. The generated files in your output directory contain:\n",
+    "\n",
+    "- **Processed data**: CSV files with read counts and comparisons\n",
+    "- **Visualizations**: PNG files showing scatter plots and distribution comparisons\n",
+    "- **Summary statistics**: Correlation metrics and fold change analysis\n",
+    "\n",
+    "You can modify the input parameters in Step 2 to analyze different FASTQ directories or plate maps."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "qiime2-metagenome-2024.5",
+   "language": "python",
+   "name": "qiime2-metagenome-2024.5"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}