sample_sheet <- "sample_sheets/dda_samples.xlsx"
savefile <- "mzxml_dda_data_201805.rda"

metadata <- openxlsx::read.xlsx(sample_sheet)
keeper_idx <- metadata[["sampledate"]] == "20180420"
metadata <- metadata[keeper_idx, ]

knitr::kable(metadata)

if (file.exists(savefile)) {
  load(savefile)
} else {
  mzxml_data <- sm(extract_mzxml_data(metadata,
                                      file_column="mzxmlfile",
                                      savefile=savefile))
}

intensity_boxplot <- sm(plot_mzxml_boxplot(mzxml_data))
pp(file="images/mzxml_intensities.png", image=intensity_boxplot)

retention_boxplot <- sm(plot_mzxml_boxplot(mzxml_data, table="scans", column="peakscount"))
pp(file="images/mzxml_retention.png", image=retention_boxplot)

mz_boxplot <- sm(plot_mzxml_boxplot(mzxml_data, table="scans", column="basepeakmz"))
pp(file="images/mzxml_mzbase.png", image=mz_boxplot)

scanintensity_boxplot <- sm(plot_mzxml_boxplot(mzxml_data, table="scans", column="basepeakintensity"))
pp(file="images/mzxml_scanintensity.png", image=scanintensity_boxplot)

intensity_wrt_mz <- sm(plot_intensity_mz(mzxml_data, x_scale="log", y_scale="log"))
pp(file="images/intensity_wrt_mz_dia.png", image=intensity_wrt_mz$plot)

sample_sheet <- "sample_sheets/Mtb_dia_samples.xlsx"
savefile <- "mzxml_dia_data_201805.rda"

metadata <- openxlsx::read.xlsx(sample_sheet)
keeper_idx <- metadata[["expt_id"]] == "may2018"
keeper_idx[is.na(keeper_idx)] <- FALSE
metadata <- metadata[keeper_idx, ]
knitr::kable(metadata)

if (file.exists(savefile)) {
  load(savefile)
} else {
  mzxml_data <- sm(extract_mzxml_data(metadata,
                                      file_column="Filename",
                                      savefile=savefile))
}

intensity_boxplot <- plot_mzxml_boxplot(mzxml_data)
pp(file="images/201805_dia_mzxml_intensities.png", image=intensity_boxplot)

retention_boxplot <- plot_mzxml_boxplot(mzxml_data, table="scans", column="peakscount")
pp(file="images/201805_dia_mzxml_retention.png", image=retention_boxplot)

mz_boxplot <- plot_mzxml_boxplot(mzxml_data, table="scans", column="basepeakmz")
pp(file="images/201805_dia_mzxml_mzbase.png", image=mz_boxplot)

scanintensity_boxplot <- plot_mzxml_boxplot(mzxml_data, table="scans", column="basepeakintensity")
pp(file="images/201805_dia_mzxml_scanintensity.png", image=scanintensity_boxplot)

intensity_wrt_mz <- plot_intensity_mz(mzxml_data, x_scale="log", y_scale="log")
pp(file="images/201805_dia_intensity_wrt_mz_dia.png", image=intensity_wrt_mz)

ls parameters
export VERSION="20180530"
source parameters/20180530_settings.sh
echo "Version is: ${VERSION}"

## Bad Password

env | grep ${VERSION}

##cd "${START}"
echo $START

## Bad Password

echo "Starting run of comet using the configuration file:
comet/comet_${DDA_METHOD}_params.txt against ${DDA_INPUTS}."
for comet_input in ${DDA_INPUTS}
do
    echo "The input is: ${comet_input}"
    /cbcb/sw/RedHat-7-x86_64/common/local/tpp/5.1.0/bin/comet \
        "-Pcomet/comet_${DDA_METHOD}_params.txt" \
        "${comet_input}" \
        2>>"comet/comet_${VERSION}.log" 1>&2
done
tail "comet/comet_${VERSION}.log"

## Bad Password

echo "Starting refreshparser to hopefully add back the alternate matches dropped by comet."
for refresh_input in ${PEPXML_INPUTS}
do
    echo "The input is: ${refresh_input}."
    RefreshParser \
        "${refresh_input}" \
        "${REFDB}" \
        2>>${refresh_input}.log 1>&2
done

## Bad Password

echo "Invoking xinteract to merge searches, set decoys, and set up fdr."
mkdir -p "results/fdr_controlled_${VERSION}_${TYPE}"
echo "The input is: ${PEPXML_INPUTS}"
echo "The output is: ${FDR_RESULT}"
xinteract \
    "-d${DECOY_STRING}" \
    -OARPpd \
    -Ow \
    "-N${FDR_RESULT}" \
    "mzXML/dda_${VERSION}_${TYPE}"/*.pep.xml \
    2>>"${FDR_RESULT}.log" 1>&2
tail "${FDR_RESULT}.log"
grep "${TEST}" "${FDR_RESULT}" | head

## Bad Password

echo "Invoking the InterProphetParser to combine multiple identifications of the same peptide."
mkdir -p "results/iprophet_${VERSION}_${TYPE}"
echo "The input is: ${FDR_RESULT}"
echo "The output is: ${IPP_RESULT}"
InterProphetParser \
    "DECOY=${DECOY_STRING}" \
    "${FDR_RESULT}" \
    "${IPP_RESULT}" \
    2>"${IPP_RESULT}.log" 1>&2
tail "${IPP_RESULT}.log"
grep "${TEST}" "${IPP_RESULT}" | head

## Bad Password

echo "Invoking mayu to standardize the fdr estimates."
mkdir -p "results/mayu_${VERSION}_${TYPE}"
echo "The input is: ${IPP_RESULT}"
Mayu.pl \
    -A "${IPP_RESULT}" \
    -C "${REFDB}" \
    -E "${DECOY_STRING}" \
    -G "${CONFIDENCE_CUTOFF}" \
    -H 101 \
    -I "${CLEAVAGES}" \
    2>"${MAYU_OUT}" 1>&2
head "${MAYU_OUT}"
## Did it work?
## I need to figure out how to include my generated decoys...
mkdir -p mayu
mayu_prefix=$(date +%Y-%m-%d)
mv "${mayu_prefix}"* results/mayu/

## Bad Password

echo "Creating initial spectral libraries with spectrast."
echo "If a single input was given, make sure to link it to comet.mzXML."
mkdir -p results/spectral_libraries
rm -f "${SPECTRAL_BASENAME}*"
echo "The input is: ${SPECTRAL_BASENAME}"
echo "The output is: ${IPP_RESULT}"
spectrast \
    "-cN${SPECTRAL_BASENAME}" \
    "-cI${DDA_METHOD}" \
    -cf "Protein! ~ ${DECOY_STRING}" \
    "-cP${IPPP}" \
    -c_IRR \
    "${IPP_RESULT}" \
    2>>${IPP_RESULT}.log 1>&2
tail "${IPP_RESULT}.log"
grep "${TEST}" "${SPECTRAL_BASENAME}.sptxt" | head

## Bad Password

echo "Making initial consensus libraries with spectrast."
echo "The input is: ${SPECTRAL_LIBRARY}"
echo "The output is: ${CONSENSUS}"
mkdir -p results/spectral_consensus
spectrast \
    "-cN${CONSENSUS}" \
    "-cI${DDA_METHOD}" \
    -cAC \
    "${SPECTRAL_LIBRARY}" \
    2>>"${CONSENSUS}.log" 1>&2
tail "${CONSENSUS}.log"
grep "${TEST}" "${CONSENSUS}.sptxt" | head

## Bad Password

echo "Make sure you have created an acquisition window file _without_ a header."
echo "There should be some which are just bob.txt in the windows/ directory."
echo "Writing spectrast tsv files with spectrast2tsv."
echo "Making a consensus library specific for ${MZ_WINDOWS} windows."
echo "The input is: ${CONSENSUS}.sptxt"
echo "The output is: ${CONSENSUS}_${MZ_WINDOWS}.tsv"
spectrast2tsv.py \
    -l 350,2000 \
    -s b,y \
    -x 1,2 \
    -o 4 \
    -n 6 \
    -p "${CONFIDENCE_CUTOFF}" \
    -d \
    -e \
    -w "windows/acquisition_${MZ_WINDOWS}.txt" \
    -k openswath \
    -a "${CONSENSUS}_${MZ_WINDOWS}.tsv" \
    "${CONSENSUS}.sptxt" \
    2>>"${CONSENSUS}_spectrast2tsv.log" 1>&2
tail "${CONSENSUS}_spectrast2tsv.log"
grep "${TEST}" "${CONSENSUS}_${MZ_WINDOWS}.tsv" | head

## Bad Password

echo "Converting spectral libraries to TraML."
rm -f "${CONSENSUS}_${MZ_WINDOWS}.TraML"
echo "The input is: ${CONSENSUS}_${MZ_WINDOWS}.tsv"
echo "The output is: ${CONSENSUS}_${MZ_WINDOWS}.TraML"
TargetedFileConverter \
    -in "${CONSENSUS}_${MZ_WINDOWS}.tsv" \
    -in_type tsv \
    -out "${CONSENSUS}_${MZ_WINDOWS}.TraML" \
    -out_type TraML

## Bad Password

echo "Adding decoys and optimizing the spectral libraries."
rm -f "${CONSENSUS}_${MZ_WINDOWS}_decoy.TraML"
echo "Generating decoys for ${CONSENSUS}_${MZ_WINDOWS}"
echo "Optimizing the consensus library."
echo "The input is: ${CONSENSUS_TRAML}"
echo "The output is: ${OPTIMIZED_TRAML}"
OpenSwathAssayGenerator \
     -in "${CONSENSUS_TRAML}" \
     -out "${OPTIMIZED_TRAML}" \
     -swath_windows_file "windows/openswath_${MZ_WINDOWS}.txt" \
     -enable_ipf \
     -unimod_file "parameters/unimod.xml" \
     2>>"${OPTIMIZED_TRAML}.log" 1>&2
tail "${OPTIMIZED_TRAML}.log"

echo "Adding decoys."
echo "The input is: ${OPTIMIZED_TRAML}"
echo "The output is: ${DECOY_TRAML}"
OpenSwathDecoyGenerator \
    -in "${OPTIMIZED_TRAML}" \
    -out "${DECOY_TRAML}" \
    -decoy_tag "${DECOY_STRING}" \
    -method shuffle \
    2>>"${DECOY_TRAML}.log" 1>&2
tail "${DECOY_TRAML}.log"
grep "${TEST}" "${CONSENSUS}_${MZ_WINDOWS}_decoy.TraML" | head

## Bad Password

echo "Converting decoy-added libraries back to tsv for examination later."
rm -f "${CONSENSUS}_${MZ_WINDOWS}_decoy.tsv"
echo "The input is: ${DECOY_TRAML}"
echo "The output is: ${TRANSITION_PREFIX}.tsv"
TargetedFileConverter \
    -in "${DECOY_TRAML}" \
    -in_type TraML \
    -out "${TRANSITION_PREFIX}.tsv" \
    -out_type tsv

echo "Converting libraries with decoys for ${TRANSITION_PREFIX} to pqp."
echo "The input is: ${DECOY_TRAML}"
echo "The output is: ${TRANSITION_PREFIX}.pqp"
TargetedFileConverter \
    -in "${TRANSITION_PREFIX}.tsv" \
    -in_type tsv \
    -out_type pqp \
    -out "${TRANSITION_PREFIX}.pqp"
echo "Transition library for openswathworkflow is: ${TRANSITION_PREFIX}.pqp"
grep "${TEST}" "${TRANSITION_PREFIX}.tsv" | head
grep -c "${DECOY_STRING}" "${TRANSITION_PREFIX}.tsv"

## Bad Password

echo "Invoking the OpenSwathWorkflow."
echo "Checking in, the transition library is: ${TRANSITION_PREFIX}.pqp"
swath_inputs=$(/bin/ls "mzXML/dia_${VERSION}")
echo "Checking in, the inputs are: ${SWATH_INPUTS}"
mkdir -p "${SWATH_OUTDIR}"
for input in ${swath_inputs}
do
    in_mzxml="mzXML/dia_${VERSION}/${input}"
    name=$(basename "${input}" .mzXML)
    echo "Starting openswath run of ${name} using ${MZ_WINDOWS} windows at $(date)."
    swath_output_prefix="${SWATH_OUTDIR}/${name}_vs_${VERSION}_${TYPE}_${DDA_METHOD}_dia"
    echo "Deleting previous swath output file: ${SWATH_OUTPUT_PREFIX}.osw"
    rm -f "${SWATH_OUTPUT_PREFIX}.osw"
    OpenSwathWorkflow \
        -ini "parameters/openms_${VERSION}.ini" \
        -in "${in_mzxml}" \
        -swath_windows_file "windows/openswath_${name}.txt" \
        -tr "${TRANSITON_PREFIX}.pqp" \
        -out_osw "${swath_output_prefix}.osw" \
        2>"${swath_output_prefix}_osw.log" 1>&2

    echo "Scoring individual swath run: ${swath_output_prefix}"
    pyprophet \
        score \
        --level ms1 \
        --in "${swath_output_prefix}.osw" \
        2>>"${swath_output_prefix}_pyprophet_ms1.log" 1>&2

    pyprophet \
        score \
        --level ms2 \
        --in "${swath_output_prefix}.osw" \
        --out "${swath_output_prefix}_scored.osw" \
        2>>"${swath_output_prefix}_pyprophet_ms2.log" 1>&2

    pyprophet \
        protein \
        --in "${swath_output_prefix}_scored.osw" \
        --context run-specific \
        2>>"${swath_output_prefix}_pyprophet_protein.log" 1>&2

    echo "Exporting individual swath run: to ${swath_output_prefix}.tsv"
    pyprophet \
        export \
        --in "${swath_output_prefix}_scored.osw" \
        --out "${swath_output_prefix}_scored.tsv" \
        2>>"${swath_output_prefix}_pyprophet_export.log" 1>&2
done

## Bad Password

echo "Invoking the OpenSwathWorkflow using the tuberculist transitions."
swath_inputs=$(/bin/ls "mzXML/dia_${VERSION}")
echo "Checking in, the inputs are: ${swath_inputs}"
mkdir -p "${TUBERCULIST_OUTDIR}"
for input in ${swath_inputs}
do
    in_mzxml="mzXML/dia_${VERSION}/${input}"
    name=$(basename "${input}" .mzXML)
    echo "Starting openswath run of ${name} using ${MZ_WINDOWS} windows at $(date)."
    tb_output_prefix="${TUBERCULIST_OUTDIR}/${name}_vs_${VERSION}_${TYPE}_${DDA_METHOD}_dia"
    echo "Deleting previous swath output file: ${tb_output_prefix}.osw"
    rm -f "${tb_output_prefix}.osw"
    OpenSwathWorkflow \
        -ini "parameters/openms_${VERSION}.ini" \
        -in "${in_mzxml}" \
        -swath_windows_file "windows/openswath_${name}.txt" \
        -tr "${TUBERCULIST_PQP}" \
        -out_osw "${tb_output_prefix}.osw" \
        2>"${tb_output_prefix}_osw.log" 1>&2

    echo "Scoring individual swath run: ${tb_output_prefix}"
    pyprophet \
        score \
        --level ms1 \
        --in "${tb_output_prefix}.osw" \
        2>>"${tb_output_prefix}_pyprophet_ms1.log" 1>&2

    pyprophet \
        score \
        --level ms2 \
        --in "${tb_output_prefix}.osw" \
        --out "${tb_output_prefix}_scored.osw" \
        2>>"${tb_output_prefix}_pyprophet_ms2.log" 1>&2

    pyprophet \
        protein \
        --in "${tb_output_prefix}_scored.osw" \
        --context run-specific \
        2>>"${tb_output_prefix}_pyprophet_protein.log" 1>&2

    echo "Exporting individual swath run: to ${tb_output_prefix}.tsv"
    pyprophet \
        export \
        --in "${tb_output_prefix}_scored.osw" \
        --out "${tb_output_prefix}_scored.tsv" \
        2>>"${tb_output_prefix}_pyprophet_export.log" 1>&2
done

## Bad Password

feature_alignment.py \
    --force \
    --in "./${SWATH_OUTDIR}/"*.tsv \
    --out "${TRIC_OUTDIR}/${SEARCH_METHOD}_${DDA_METHOD}.tsv" \
    --out_matrix "${TRIC_OUTDIR}/${DDA_METHOD}_outmatrix.tsv" \
    --out_meta "${TRIC_OUTDIR}/${DDA_METHOD}_meta.tsv"
echo "Wrote final output to ${TRIC_OUTDIR}/${SEARCH_METHOD}_${DDA_METHOD}.tsv"

## Bad Password

tric_tb="${TRIC_OUTDIR}_tb"
feature_alignment.py \
    --force \
    --in "./${SWATH_OUTDIR}/"*.tsv \
    --out "${tric_tb}/${SEARCH_METHOD}_${DDA_METHOD}.tsv" \
    --out_matrix "${tric_tb}/${DDA_METHOD}_outmatrix.tsv" \
    --out_meta "${tric_tb}/${DDA_METHOD}_meta.tsv"
echo "Wrote final output to ${tric_tb}/${SEARCH_METHOD}_${DDA_METHOD}.tsv"

## Bad Password

if (!isTRUE(get0("skip_load"))) {
  message(paste0("This is hpgltools commit: ", get_git_commit()))
  this_save <- paste0(gsub(pattern="\\.Rmd", replace="", x=rmd_file), "-v", ver, ".rda.xz")
  message(paste0("Saving to ", this_save))
  tmp <- sm(saveme(filename=this_save))
  pander::pander(sessionInfo())
}

## If you wish to reproduce this exact build of hpgltools, invoke the following:

## > git clone http://github.com/abelew/hpgltools.git

## > git reset 4523f8cfb1df75584e2257a89e1810ee13c56a67

## R> packrat::restore()

## This is hpgltools commit: Tue May 29 16:09:33 2018 -0400: 4523f8cfb1df75584e2257a89e1810ee13c56a67

## Saving to 01_preprocessing_comet_20180508-v20180215.rda.xz

b$stop()

---
title: "M.tuberculosis 20180530: Preprocessing DIA data with a comet highres library (more samples)."
author: "atb abelew@gmail.com"
date: "`r Sys.Date()`"
output:
 html_document:
  code_download: true
  code_folding: show
  fig_caption: true
  fig_height: 7
  fig_width: 7
  highlight: default
  keep_md: false
  mode: selfcontained
  number_sections: true
  self_contained: true
  theme: readable
  toc: true
  toc_float:
    collapsed: false
    smooth_scroll: false
---

<style>
  body .main-container {
    max-width: 1600px;
  }
</style>

```{r options, include=FALSE}
if (!isTRUE(get0("skip_load"))) {
  library(hpgltools)
  library(runr)
  b <- proc_bash(port=2000)
  started <- b$start()
  knitr::knit_engines$set(bash_runr=function(options) {
    knitr:::wrap(b$exec(options$code), options)
  })
  ##tt <- devtools::load_all("~/hpgltools")
  knitr::opts_knit$set(progress=TRUE,
                       verbose=TRUE,
                       width=90,
                       echo=TRUE)
  knitr::opts_chunk$set(error=TRUE,
                        fig.width=8,
                        fig.height=8,
                        dpi=96)
  old_options <- options(digits=4,
                         stringsAsFactors=FALSE,
                         knitr.duplicate.label="allow")
  ggplot2::theme_set(ggplot2::theme_bw(base_size=10))
  ver <- "20180215"
  previous_file <- "01_annotation.Rmd"

  ##tmp <- try(sm(loadme(filename=paste0(gsub(pattern="\\.Rmd", replace="", x=previous_file), "-v", ver, ".rda.xz"))))
  rmd_file <- "01_preprocessing_comet_20180508.Rmd"
}
```

Preprocessing DIA data via the instructions at: http://dia-swath-course.ethz.ch/tutorials2017/
==============================================================================================

# Generating a high-res (HCD) spectral search library.

## Reading metadata

In theory, I have figured out how to render a mix of bash and r in multiple blocks.
This worksheet will test that theory by copy/pasting out the various sections of bash
required to do the processing of this data into blocks labeled 'bash_runr'.

If I am correct, we will be able then to test and render each piece of this
process without having to run the entire thing as a bash script at the end.

The original script which provides the meat of this document is still here in
case this fails as dia_invocation_hcd_20180530.sh.

```{r my_dda_metrics}
sample_sheet <- "sample_sheets/dda_samples.xlsx"
savefile <- "mzxml_dda_data_201805.rda"

metadata <- openxlsx::read.xlsx(sample_sheet)
keeper_idx <- metadata[["sampledate"]] == "20180420"
metadata <- metadata[keeper_idx, ]

knitr::kable(metadata)
```

## Gather data and plot metrics

```{r dda_plots, eval=FALSE}
if (file.exists(savefile)) {
  load(savefile)
} else {
  mzxml_data <- sm(extract_mzxml_data(metadata,
                                      file_column="mzxmlfile",
                                      savefile=savefile))
}

intensity_boxplot <- sm(plot_mzxml_boxplot(mzxml_data))
pp(file="images/mzxml_intensities.png", image=intensity_boxplot)

retention_boxplot <- sm(plot_mzxml_boxplot(mzxml_data, table="scans", column="peakscount"))
pp(file="images/mzxml_retention.png", image=retention_boxplot)

mz_boxplot <- sm(plot_mzxml_boxplot(mzxml_data, table="scans", column="basepeakmz"))
pp(file="images/mzxml_mzbase.png", image=mz_boxplot)

scanintensity_boxplot <- sm(plot_mzxml_boxplot(mzxml_data, table="scans", column="basepeakintensity"))
pp(file="images/mzxml_scanintensity.png", image=scanintensity_boxplot)

intensity_wrt_mz <- sm(plot_intensity_mz(mzxml_data, x_scale="log", y_scale="log"))
pp(file="images/intensity_wrt_mz_dia.png", image=intensity_wrt_mz$plot)
```

# Get DIA metrics

Do not forget that extract_mzxml_data() writes the acquisition window files
required for openswathworkflow to run, so do not forget to run it.

## Read dia metadata

```{r dia_metrics, eval=FALSE}
sample_sheet <- "sample_sheets/Mtb_dia_samples.xlsx"
savefile <- "mzxml_dia_data_201805.rda"

metadata <- openxlsx::read.xlsx(sample_sheet)
keeper_idx <- metadata[["expt_id"]] == "may2018"
keeper_idx[is.na(keeper_idx)] <- FALSE
metadata <- metadata[keeper_idx, ]
knitr::kable(metadata)
```

## Plot dia metrics

Now let us plot the dia sample data.

```{r dia_plots, eval=FALSE}
if (file.exists(savefile)) {
  load(savefile)
} else {
  mzxml_data <- sm(extract_mzxml_data(metadata,
                                      file_column="Filename",
                                      savefile=savefile))
}

intensity_boxplot <- plot_mzxml_boxplot(mzxml_data)
pp(file="images/201805_dia_mzxml_intensities.png", image=intensity_boxplot)

retention_boxplot <- plot_mzxml_boxplot(mzxml_data, table="scans", column="peakscount")
pp(file="images/201805_dia_mzxml_retention.png", image=retention_boxplot)

mz_boxplot <- plot_mzxml_boxplot(mzxml_data, table="scans", column="basepeakmz")
pp(file="images/201805_dia_mzxml_mzbase.png", image=mz_boxplot)

scanintensity_boxplot <- plot_mzxml_boxplot(mzxml_data, table="scans", column="basepeakintensity")
pp(file="images/201805_dia_mzxml_scanintensity.png", image=scanintensity_boxplot)

intensity_wrt_mz <- plot_intensity_mz(mzxml_data, x_scale="log", y_scale="log")
pp(file="images/201805_dia_intensity_wrt_mz_dia.png", image=intensity_wrt_mz)
```

# Gathering parameters

In this first block, I will set a couple of variables and source a file
containing the parameters for the rest of the script.

```{bash_runr parameters}
ls parameters
export VERSION="20180530"
source parameters/20180530_settings.sh
echo "Version is: ${VERSION}"
```

```{r sleep1, include=FALSE}
Sys.sleep(1)
```

## Test that we have the required variables for the rest of the script.

```{bash_runr test_params}
env | grep ${VERSION}

##cd "${START}"
echo $START
```

```{r sleep2, include=FALSE}
Sys.sleep(1)
```

# Run comet on our DDA data

```{bash_runr comet}
echo "Starting run of comet using the configuration file:
comet/comet_${DDA_METHOD}_params.txt against ${DDA_INPUTS}."
for comet_input in ${DDA_INPUTS}
do
    echo "The input is: ${comet_input}"
    /cbcb/sw/RedHat-7-x86_64/common/local/tpp/5.1.0/bin/comet \
        "-Pcomet/comet_${DDA_METHOD}_params.txt" \
        "${comet_input}" \
        2>>"comet/comet_${VERSION}.log" 1>&2
done
tail "comet/comet_${VERSION}.log"
```

```{r sleep3, include=FALSE}
Sys.sleep(1)
```

# Refresh the comet results

Comet does not provide the alternate hits, the following should add them into
the comet output files.

```{bash_runr comet_refresh}
echo "Starting refreshparser to hopefully add back the alternate matches dropped by comet."
for refresh_input in ${PEPXML_INPUTS}
do
    echo "The input is: ${refresh_input}."
    RefreshParser \
        "${refresh_input}" \
        "${REFDB}" \
        2>>${refresh_input}.log 1>&2
done
```

```{r sleep4, include=FALSE}
Sys.sleep(1)
```

# Merge searches

```{bash_runr xinteract_merge}
echo "Invoking xinteract to merge searches, set decoys, and set up fdr."
mkdir -p "results/fdr_controlled_${VERSION}_${TYPE}"
echo "The input is: ${PEPXML_INPUTS}"
echo "The output is: ${FDR_RESULT}"
xinteract \
    "-d${DECOY_STRING}" \
    -OARPpd \
    -Ow \
    "-N${FDR_RESULT}" \
    "mzXML/dda_${VERSION}_${TYPE}"/*.pep.xml \
    2>>"${FDR_RESULT}.log" 1>&2
tail "${FDR_RESULT}.log"
grep "${TEST}" "${FDR_RESULT}" | head
```

```{r sleep5, include=FALSE}
Sys.sleep(1)
```

# Combine multiple identifications

```{bash_runr interprophet}
echo "Invoking the InterProphetParser to combine multiple identifications of the same peptide."
mkdir -p "results/iprophet_${VERSION}_${TYPE}"
echo "The input is: ${FDR_RESULT}"
echo "The output is: ${IPP_RESULT}"
InterProphetParser \
    "DECOY=${DECOY_STRING}" \
    "${FDR_RESULT}" \
    "${IPP_RESULT}" \
    2>"${IPP_RESULT}.log" 1>&2
tail "${IPP_RESULT}.log"
grep "${TEST}" "${IPP_RESULT}" | head
```

```{r sleep6, include=FALSE}
Sys.sleep(1)
```

# Mayu

```{bash_runr mayu}
echo "Invoking mayu to standardize the fdr estimates."
mkdir -p "results/mayu_${VERSION}_${TYPE}"
echo "The input is: ${IPP_RESULT}"
Mayu.pl \
    -A "${IPP_RESULT}" \
    -C "${REFDB}" \
    -E "${DECOY_STRING}" \
    -G "${CONFIDENCE_CUTOFF}" \
    -H 101 \
    -I "${CLEAVAGES}" \
    2>"${MAYU_OUT}" 1>&2
head "${MAYU_OUT}"
## Did it work?
## I need to figure out how to include my generated decoys...
mkdir -p mayu
mayu_prefix=$(date +%Y-%m-%d)
mv "${mayu_prefix}"* results/mayu/
```

```{r sleep7, include=FALSE}
Sys.sleep(1)
```

# Initial libraries spectrast

```{bash_runr spectrast1}
echo "Creating initial spectral libraries with spectrast."
echo "If a single input was given, make sure to link it to comet.mzXML."
mkdir -p results/spectral_libraries
rm -f "${SPECTRAL_BASENAME}*"
echo "The input is: ${SPECTRAL_BASENAME}"
echo "The output is: ${IPP_RESULT}"
spectrast \
    "-cN${SPECTRAL_BASENAME}" \
    "-cI${DDA_METHOD}" \
    -cf "Protein! ~ ${DECOY_STRING}" \
    "-cP${IPPP}" \
    -c_IRR \
    "${IPP_RESULT}" \
    2>>${IPP_RESULT}.log 1>&2
tail "${IPP_RESULT}.log"
grep "${TEST}" "${SPECTRAL_BASENAME}.sptxt" | head
```

```{r sleep8, include=FALSE}
Sys.sleep(1)
```

# Initial consensus spectrast

```{bash_runr spectrast2}
echo "Making initial consensus libraries with spectrast."
echo "The input is: ${SPECTRAL_LIBRARY}"
echo "The output is: ${CONSENSUS}"
mkdir -p results/spectral_consensus
spectrast \
    "-cN${CONSENSUS}" \
    "-cI${DDA_METHOD}" \
    -cAC \
    "${SPECTRAL_LIBRARY}" \
    2>>"${CONSENSUS}.log" 1>&2
tail "${CONSENSUS}.log"
grep "${TEST}" "${CONSENSUS}.sptxt" | head
```

```{r sleep9, include=FALSE}
Sys.sleep(1)
```

# Converting consensus libraries to tsv for later examination

```{bash_runr spectrast2tsv}
echo "Make sure you have created an acquisition window file _without_ a header."
echo "There should be some which are just bob.txt in the windows/ directory."
echo "Writing spectrast tsv files with spectrast2tsv."
echo "Making a consensus library specific for ${MZ_WINDOWS} windows."
echo "The input is: ${CONSENSUS}.sptxt"
echo "The output is: ${CONSENSUS}_${MZ_WINDOWS}.tsv"
spectrast2tsv.py \
    -l 350,2000 \
    -s b,y \
    -x 1,2 \
    -o 4 \
    -n 6 \
    -p "${CONFIDENCE_CUTOFF}" \
    -d \
    -e \
    -w "windows/acquisition_${MZ_WINDOWS}.txt" \
    -k openswath \
    -a "${CONSENSUS}_${MZ_WINDOWS}.tsv" \
    "${CONSENSUS}.sptxt" \
    2>>"${CONSENSUS}_spectrast2tsv.log" 1>&2
tail "${CONSENSUS}_spectrast2tsv.log"
grep "${TEST}" "${CONSENSUS}_${MZ_WINDOWS}.tsv" | head
```

```{r sleep10, include=FALSE}
Sys.sleep(1)
```

# Converting consensus libraries to TraML

```{bash_runr totraml}
echo "Converting spectral libraries to TraML."
rm -f "${CONSENSUS}_${MZ_WINDOWS}.TraML"
echo "The input is: ${CONSENSUS}_${MZ_WINDOWS}.tsv"
echo "The output is: ${CONSENSUS}_${MZ_WINDOWS}.TraML"
TargetedFileConverter \
    -in "${CONSENSUS}_${MZ_WINDOWS}.tsv" \
    -in_type tsv \
    -out "${CONSENSUS}_${MZ_WINDOWS}.TraML" \
    -out_type TraML
```

```{r sleep11, include=FALSE}
Sys.sleep(1)
```

# Add decoys to the TraML

```{bash_runr decoy_traml}
echo "Adding decoys and optimizing the spectral libraries."
rm -f "${CONSENSUS}_${MZ_WINDOWS}_decoy.TraML"
echo "Generating decoys for ${CONSENSUS}_${MZ_WINDOWS}"
echo "Optimizing the consensus library."
echo "The input is: ${CONSENSUS_TRAML}"
echo "The output is: ${OPTIMIZED_TRAML}"
OpenSwathAssayGenerator \
     -in "${CONSENSUS_TRAML}" \
     -out "${OPTIMIZED_TRAML}" \
     -swath_windows_file "windows/openswath_${MZ_WINDOWS}.txt" \
     -enable_ipf \
     -unimod_file "parameters/unimod.xml" \
     2>>"${OPTIMIZED_TRAML}.log" 1>&2
tail "${OPTIMIZED_TRAML}.log"

echo "Adding decoys."
echo "The input is: ${OPTIMIZED_TRAML}"
echo "The output is: ${DECOY_TRAML}"
OpenSwathDecoyGenerator \
    -in "${OPTIMIZED_TRAML}" \
    -out "${DECOY_TRAML}" \
    -decoy_tag "${DECOY_STRING}" \
    -method shuffle \
    2>>"${DECOY_TRAML}.log" 1>&2
tail "${DECOY_TRAML}.log"
grep "${TEST}" "${CONSENSUS}_${MZ_WINDOWS}_decoy.TraML" | head
```

```{r sleep12, include=FALSE}
Sys.sleep(1)
```

# Convert back to tsv/pqp

```{bash_runr convert_back}
echo "Converting decoy-added libraries back to tsv for examination later."
rm -f "${CONSENSUS}_${MZ_WINDOWS}_decoy.tsv"
echo "The input is: ${DECOY_TRAML}"
echo "The output is: ${TRANSITION_PREFIX}.tsv"
TargetedFileConverter \
    -in "${DECOY_TRAML}" \
    -in_type TraML \
    -out "${TRANSITION_PREFIX}.tsv" \
    -out_type tsv

echo "Converting libraries with decoys for ${TRANSITION_PREFIX} to pqp."
echo "The input is: ${DECOY_TRAML}"
echo "The output is: ${TRANSITION_PREFIX}.pqp"
TargetedFileConverter \
    -in "${TRANSITION_PREFIX}.tsv" \
    -in_type tsv \
    -out_type pqp \
    -out "${TRANSITION_PREFIX}.pqp"
echo "Transition library for openswathworkflow is: ${TRANSITION_PREFIX}.pqp"
grep "${TEST}" "${TRANSITION_PREFIX}.tsv" | head
grep -c "${DECOY_STRING}" "${TRANSITION_PREFIX}.tsv"
```

```{r sleep13, include=FALSE}
Sys.sleep(1)
```

# OpenSwathWorkflow against our experimental transitions

```{bash_runr openswath_our}
echo "Invoking the OpenSwathWorkflow."
echo "Checking in, the transition library is: ${TRANSITION_PREFIX}.pqp"
swath_inputs=$(/bin/ls "mzXML/dia_${VERSION}")
echo "Checking in, the inputs are: ${SWATH_INPUTS}"
mkdir -p "${SWATH_OUTDIR}"
for input in ${swath_inputs}
do
    in_mzxml="mzXML/dia_${VERSION}/${input}"
    name=$(basename "${input}" .mzXML)
    echo "Starting openswath run of ${name} using ${MZ_WINDOWS} windows at $(date)."
    swath_output_prefix="${SWATH_OUTDIR}/${name}_vs_${VERSION}_${TYPE}_${DDA_METHOD}_dia"
    echo "Deleting previous swath output file: ${SWATH_OUTPUT_PREFIX}.osw"
    rm -f "${SWATH_OUTPUT_PREFIX}.osw"
    OpenSwathWorkflow \
        -ini "parameters/openms_${VERSION}.ini" \
        -in "${in_mzxml}" \
        -swath_windows_file "windows/openswath_${name}.txt" \
        -tr "${TRANSITON_PREFIX}.pqp" \
        -out_osw "${swath_output_prefix}.osw" \
        2>"${swath_output_prefix}_osw.log" 1>&2

    echo "Scoring individual swath run: ${swath_output_prefix}"
    pyprophet \
        score \
        --level ms1 \
        --in "${swath_output_prefix}.osw" \
        2>>"${swath_output_prefix}_pyprophet_ms1.log" 1>&2

    pyprophet \
        score \
        --level ms2 \
        --in "${swath_output_prefix}.osw" \
        --out "${swath_output_prefix}_scored.osw" \
        2>>"${swath_output_prefix}_pyprophet_ms2.log" 1>&2

    pyprophet \
        protein \
        --in "${swath_output_prefix}_scored.osw" \
        --context run-specific \
        2>>"${swath_output_prefix}_pyprophet_protein.log" 1>&2

    echo "Exporting individual swath run: to ${swath_output_prefix}.tsv"
    pyprophet \
        export \
        --in "${swath_output_prefix}_scored.osw" \
        --out "${swath_output_prefix}_scored.tsv" \
        2>>"${swath_output_prefix}_pyprophet_export.log" 1>&2
done
```

```{r sleep14, include=FALSE}
Sys.sleep(1)
```

# OpenSwathWorkflow against our the Tuberculist transitions

```{bash_runr openswath_tuberculist}
echo "Invoking the OpenSwathWorkflow using the tuberculist transitions."
swath_inputs=$(/bin/ls "mzXML/dia_${VERSION}")
echo "Checking in, the inputs are: ${swath_inputs}"
mkdir -p "${TUBERCULIST_OUTDIR}"
for input in ${swath_inputs}
do
    in_mzxml="mzXML/dia_${VERSION}/${input}"
    name=$(basename "${input}" .mzXML)
    echo "Starting openswath run of ${name} using ${MZ_WINDOWS} windows at $(date)."
    tb_output_prefix="${TUBERCULIST_OUTDIR}/${name}_vs_${VERSION}_${TYPE}_${DDA_METHOD}_dia"
    echo "Deleting previous swath output file: ${tb_output_prefix}.osw"
    rm -f "${tb_output_prefix}.osw"
    OpenSwathWorkflow \
        -ini "parameters/openms_${VERSION}.ini" \
        -in "${in_mzxml}" \
        -swath_windows_file "windows/openswath_${name}.txt" \
        -tr "${TUBERCULIST_PQP}" \
        -out_osw "${tb_output_prefix}.osw" \
        2>"${tb_output_prefix}_osw.log" 1>&2

    echo "Scoring individual swath run: ${tb_output_prefix}"
    pyprophet \
        score \
        --level ms1 \
        --in "${tb_output_prefix}.osw" \
        2>>"${tb_output_prefix}_pyprophet_ms1.log" 1>&2

    pyprophet \
        score \
        --level ms2 \
        --in "${tb_output_prefix}.osw" \
        --out "${tb_output_prefix}_scored.osw" \
        2>>"${tb_output_prefix}_pyprophet_ms2.log" 1>&2

    pyprophet \
        protein \
        --in "${tb_output_prefix}_scored.osw" \
        --context run-specific \
        2>>"${tb_output_prefix}_pyprophet_protein.log" 1>&2

    echo "Exporting individual swath run: to ${tb_output_prefix}.tsv"
    pyprophet \
        export \
        --in "${tb_output_prefix}_scored.osw" \
        --out "${tb_output_prefix}_scored.tsv" \
        2>>"${tb_output_prefix}_pyprophet_export.log" 1>&2
done
```

```{r sleep15, include=FALSE}
Sys.sleep(1)
```

# Merging our data with TRIC

```{bash_runr}
feature_alignment.py \
    --force \
    --in "./${SWATH_OUTDIR}/"*.tsv \
    --out "${TRIC_OUTDIR}/${SEARCH_METHOD}_${DDA_METHOD}.tsv" \
    --out_matrix "${TRIC_OUTDIR}/${DDA_METHOD}_outmatrix.tsv" \
    --out_meta "${TRIC_OUTDIR}/${DDA_METHOD}_meta.tsv"
echo "Wrote final output to ${TRIC_OUTDIR}/${SEARCH_METHOD}_${DDA_METHOD}.tsv"
```

```{r sleep16, include=FALSE}
Sys.sleep(1)
```

# Merging the Tuberculist-derived data with TRIC

```{bash_runr}
tric_tb="${TRIC_OUTDIR}_tb"
feature_alignment.py \
    --force \
    --in "./${SWATH_OUTDIR}/"*.tsv \
    --out "${tric_tb}/${SEARCH_METHOD}_${DDA_METHOD}.tsv" \
    --out_matrix "${tric_tb}/${DDA_METHOD}_outmatrix.tsv" \
    --out_meta "${tric_tb}/${DDA_METHOD}_meta.tsv"
echo "Wrote final output to ${tric_tb}/${SEARCH_METHOD}_${DDA_METHOD}.tsv"
```

# Index version: `r ver`

# TODO

* 2017-06-14:

```{r saveme}
if (!isTRUE(get0("skip_load"))) {
  message(paste0("This is hpgltools commit: ", get_git_commit()))
  this_save <- paste0(gsub(pattern="\\.Rmd", replace="", x=rmd_file), "-v", ver, ".rda.xz")
  message(paste0("Saving to ", this_save))
  tmp <- sm(saveme(filename=this_save))
  pander::pander(sessionInfo())
}
b$stop()
```
