Discuss: Targeted proteomics support in quantms ecosystem.

[thanadol-git]

Description of feature

Hi,

I hope you are doing well.

I basically just want to discuss the format of targeted proteomics. Briefly, in our group, we used stable isotope standards to spike-in human plasma samples for absolute protein identification. For the past years, we have been using graphical software such as Skyline to extract chromatograms and peak areas. Since last year, I have analysed some projects using quantms with an SDRF file. I am wondering whether targeted proteomics, which is currently a topic of discussion, would have its own format to accommodate its specific requirements.

Right now, there might be several tools that work similarly on the experimental and bioinformatic sides. I think there should be a common ground to discuss between different parties within the scope of the metadata.

Feel free to write your idea. I must admit that I might not have much more experiences than the techniques that we are doing in our group. I would highly appreciate it if you would share any thoughts on developing this project.

Best,
Thanadol

[ypriverol]

@thanadol-git Can you explain more about the protocol you use for SRM and PRM analysis in your lab, which tools and steps; would be also good to have some public PRIDE experiment that can help us to understand the project and how do you want quantms ecosystem to support your data flow.

[jpfeuffer]

Additionally, what kind of metadata do you think would need to be encoded in the SDRF? Those are usually things that should always be used in the same way in an analysis workflow [like used enzyme and instrument] (and not up to an analyzer's preference [like FDR cutoff or search engine to use]).

[ypriverol]

Good point from @jpfeuffer I think we have to split this into two issues:

• Support of SDRF for SRM/PRM target experiments; for that I recommend to create an issue in here https://github.com/bigbio/proteomics-sample-metadata/issues
• Support in quantms for analysis of PRM/SRM experiments; We can continue the discussion on this issue. I will rename this issue.

[thanadol-git]

@ypriverol That's true. I will add another issue at SDRF.

@jpfeuffer The main information, I think, should contain spiked-in standard system including target ids, protein/peptide seqence, and defintiely spiked-in concentration. I might not have all experiences in different types of the standards.

[thanadol-git]

I have created another issue on SDRF here.

[thanadol-git]

The spiked-in standards that we are using at the Human Protein Atlas (HPA) is called Stable Isotope Standard for Protein Epitope Signature Tags (SIS-PrESTs). Briefly, it is based on the recombinant antigen protein produced in a heavy nitrogen Lysine and Arginine medium. We purified them similarly to a standard antigen production, and when we used them, we just spiked them into the plasma samples at a known concentration. This allows us to create a pool of plasma targets for absolute quantification, which we need software like Skyline to extract the results and later perform downstream analysis on it.

The main issues that we have at the moment come from two things. First, targeted proteomics has become much faster, with greater complexity. We acquired the LIT Stellar last year, and one can generate the result within just a few minutes. Meaning that in one day, a cohort of a thousand samples might be possible to achieve after sample preparation. Two, it's too complex to check results in Skyline using the graphical interface (How would you check 100 protein targets with many thousands of peptides for several thousand samples with your eyes?).

I might not have much experience with other software, but I did try some of our SRM results with OpenSWATH, for example. I think this might be a possible conceptually (I might be wrong).

Looking forward to your ideas and discussion.

Please check the papers below:

1. https://pubmed.ncbi.nlm.nih.gov/21964433/
2. https://www.sciencedirect.com/science/article/pii/S1535947620305053?via%3Dihub

[timosachsenberg]

I had a quick discussion with our OpenSWATH guys and they think this should be possible without many changes.
Have you already been successful with OpenMS?

Otherwise this is how it could work:

Analyzing SRM/PRM Data with OpenMS

A comprehensive guide for processing targeted proteomics data (SRM/PRM) using OpenMS tools.

I did some AI research on our codebase to summarise what tools we have:

Workflow 1: SRM Data (Triple Quadrupole)

SRM data from instruments like Agilent 6460, SCIEX QTRAP, or Thermo TSQ already contains pre-extracted chromatograms in the mzML file.

┌─────────────┐     ┌────────────┐     ┌────────────────────────┐     ┌─────────────┐
│ SRM mzML    │ ──► │ MRMMapper  │ ──► │ MRMTransitionGroupPicker│ ──► │FeatureXML  │
│(chromatograms)│   │            │     │                        │     │(quantified) │
└─────────────┘     └────────────┘     └────────────────────────┘     └─────────────┘
       +                  │
┌─────────────┐           │
│ TraML       │ ──────────┘
│(transitions)│
└─────────────┘

Step 1: Map chromatograms to transitions

MRMMapper \
    -in srm_sample.mzML \
    -tr transitions.traML \
    -out srm_mapped.mzML \
    -algorithm:precursor_tolerance 0.1 \
    -algorithm:product_tolerance 0.1

Step 2: Pick peaks in transition groups

MRMTransitionGroupPicker \
    -in srm_mapped.mzML \
    -tr transitions.traML \
    -out srm_features.featureXML \
    -algorithm:PeakPickerChromatogram:sgolay_frame_length 9 \
    -algorithm:PeakPickerChromatogram:sgolay_polynomial_order 3 \
    -algorithm:min_peak_width 5.0 \
    -algorithm:peak_integration smooth

Complete SRM Pipeline Script

#!/bin/bash
# process_srm.sh - Process SRM data

SAMPLE="$1"
TRANSITIONS="transitions.traML"
OUT_DIR="results"

mkdir -p "$OUT_DIR"

BASENAME=$(basename "$SAMPLE" .mzML)

# Step 1: Map chromatograms to transitions
MRMMapper \
    -in "$SAMPLE" \
    -tr "$TRANSITIONS" \
    -out "${OUT_DIR}/${BASENAME}_mapped.mzML" \
    -algorithm:precursor_tolerance 0.1 \
    -algorithm:product_tolerance 0.1

# Step 2: Pick peaks
MRMTransitionGroupPicker \
    -in "${OUT_DIR}/${BASENAME}_mapped.mzML" \
    -tr "$TRANSITIONS" \
    -out "${OUT_DIR}/${BASENAME}_features.featureXML" \
    -algorithm:min_peak_width 5.0

echo "Processed: $SAMPLE -> ${OUT_DIR}/${BASENAME}_features.featureXML"

---

Workflow 2: PRM Data (High-Resolution Targeted MS2)

PRM data contains targeted MS2 spectra (not pre-extracted chromatograms). You need to extract XICs from the fragment ions.
Correct this if I'm wrong but I don't have hands on experience with PRM so far.

┌─────────────┐     ┌───────────────────────────┐     ┌────────────────────────┐     ┌─────────────┐
│ PRM mzML    │ ──► │ OpenSwathChromatogram-    │ ──► │ MRMTransitionGroupPicker│ ──► │FeatureXML  │
│(MS2 spectra)│     │ Extractor                 │     │                        │     │(quantified) │
└─────────────┘     └───────────────────────────┘     └────────────────────────┘     └─────────────┘
       +                      │                               │
┌─────────────┐               │                               │
│ TraML       │ ──────────────┴───────────────────────────────┘
│(transitions)│
└─────────────┘

Step 1: Extract chromatograms from MS2 spectra

OpenSwathChromatogramExtractor \
    -in prm_sample.mzML \
    -tr transitions.traML \
    -out prm_chromatograms.mzML \
    -mz_window 20 \
    -ppm \
    -rt_window 300 \
    -extraction_function tophat

Note: Do NOT use -is_swath flag for PRM data. That flag is for DIA/SWATH with isolation windows.

Step 2: Pick peaks in transition groups

MRMTransitionGroupPicker \
    -in prm_chromatograms.mzML \
    -tr transitions.traML \
    -out prm_features.featureXML \
    -algorithm:PeakPickerChromatogram:sgolay_frame_length 11 \
    -algorithm:min_peak_width 10.0

Complete PRM Pipeline Script

Parameter might need some changes.

#!/bin/bash
# process_prm.sh - Process PRM data

SAMPLE="$1"
TRANSITIONS="transitions.traML"
OUT_DIR="results"
MZ_WINDOW=20  # ppm
RT_WINDOW=300 # seconds

mkdir -p "$OUT_DIR"

BASENAME=$(basename "$SAMPLE" .mzML)

# Step 1: Extract chromatograms from targeted MS2 spectra
OpenSwathChromatogramExtractor \
    -in "$SAMPLE" \
    -tr "$TRANSITIONS" \
    -out "${OUT_DIR}/${BASENAME}_chroms.mzML" \
    -mz_window $MZ_WINDOW \
    -ppm \
    -rt_window $RT_WINDOW \
    -extraction_function tophat

# Step 2: Pick peaks
MRMTransitionGroupPicker \
    -in "${OUT_DIR}/${BASENAME}_chroms.mzML" \
    -tr "$TRANSITIONS" \
    -out "${OUT_DIR}/${BASENAME}_features.featureXML" \
    -algorithm:min_peak_width 10.0 \
    -algorithm:PeakPickerChromatogram:sgolay_frame_length 11

echo "Processed: $SAMPLE -> ${OUT_DIR}/${BASENAME}_features.featureXML"

---

Batch Processing Large Studies (e.g., 100,000 Samples)

Mockup workflow:

Using Nextflow

nextflow.enable.dsl=2

params.input = "data/*.mzML"
params.transitions = "transitions.traML"
params.outdir = "results"
params.data_type = "prm"  // or "srm"

process EXTRACT_CHROMATOGRAMS {
    // Only for PRM data
    cpus 2
    memory '4 GB'

    input:
    path mzml
    path transitions

    output:
    tuple val(mzml.baseName), path("*_chroms.mzML"), emit: chroms

    when:
    params.data_type == "prm"

    script:
    """
    OpenSwathChromatogramExtractor \\
        -in ${mzml} \\
        -tr ${transitions} \\
        -out ${mzml.baseName}_chroms.mzML \\
        -mz_window 20 -ppm \\
        -rt_window 300
    """
}

process MAP_CHROMATOGRAMS {
    // Only for SRM data
    cpus 1
    memory '2 GB'

    input:
    path mzml
    path transitions

    output:
    tuple val(mzml.baseName), path("*_mapped.mzML"), emit: mapped

    when:
    params.data_type == "srm"

    script:
    """
    MRMMapper \\
        -in ${mzml} \\
        -tr ${transitions} \\
        -out ${mzml.baseName}_mapped.mzML
    """
}

process PICK_PEAKS {
    publishDir "${params.outdir}", mode: 'copy'
    cpus 2
    memory '4 GB'

    input:
    tuple val(sample_id), path(chroms)
    path transitions

    output:
    path "${sample_id}_features.featureXML"

    script:
    """
    MRMTransitionGroupPicker \\
        -in ${chroms} \\
        -tr ${transitions} \\
        -out ${sample_id}_features.featureXML \\
        -algorithm:min_peak_width 10.0
    """
}

workflow {
    mzml_ch = Channel.fromPath(params.input)
    transitions = file(params.transitions)

    if (params.data_type == "prm") {
        EXTRACT_CHROMATOGRAMS(mzml_ch, transitions)
        PICK_PEAKS(EXTRACT_CHROMATOGRAMS.out.chroms, transitions)
    } else {
        MAP_CHROMATOGRAMS(mzml_ch, transitions)
        PICK_PEAKS(MAP_CHROMATOGRAMS.out.mapped, transitions)
    }
}

Run with:

nextflow run main.nf -profile slurm --input 'data/*.mzML' --transitions transitions.traML --data_type prm

---

Transition Library Formats

TraML (XML format) or TSV is supported

PrecursorMz	ProductMz	LibraryIntensity	NormalizedRetentionTime	PeptideSequence	ProteinId	TransitionId
582.82	951.49	10000	45.2	LVNELTEFAK	PROT1	PEPTIDE1_y8
582.82	822.45	8000	45.2	LVNELTEFAK	PROT1	PEPTIDE1_y7

[thanadol-git]

@timosachsenberg No, I tried some suggestions after a few discussions with Josh, but it didn't really go well. I think it might be because of me, as I have never tried OpenSWATH before. Your suggestions look really great. I will try them out right now.

[timosachsenberg]

I think first step could be to confirm that transitions can be mapped. If not, we might need a small update in the mapping code

[ypriverol]

@timosachsenberg do you think we can bring Josh and Justin to this issue to help.