public void SetRawFile(MSDataFile dataFile)
{
MsnDataScan scan = dataFile[ScanNumber] as MsnDataScan;
IsolationMZ = scan.IsolationRange.Mean;
Spectrum = dataFile.GetReadOnlyMZSpectrum(ScanNumber, true);
ScanWidth = scan.MzRange.Width;
}
private void ProcessFile(string msDataFile, bool includeLog = false, bool groupByFragmentation = true)
{
IXRawfile5 raw = null;
StreamWriter log = null;
Dictionary<string, StreamWriter> txt_outputs = null;
Dictionary<string, StreamWriter> mgf_outputs = null;
StringBuilder sb = new StringBuilder();
string filepath = msDataFile;
onStartingFile(new FilepathEventArgs(filepath));
txt_outputs = new Dictionary<string, StreamWriter>();
mgf_outputs = new Dictionary<string, StreamWriter>();
var spectrum_counts = new SortedDictionary<string, int>();
var dta_counts = new SortedDictionary<string, int>();
var retention_times = new SortedDictionary<int, double>();
var scan_filter_mzs = new SortedDictionary<int, double>();
var precursor_mzs = new SortedDictionary<int, double>();
var precursor_intensities = new SortedDictionary<int, double>();
var precursor_denormalized_intensities = new SortedDictionary<int, double>();
var precursor_charge_states = new SortedDictionary<int, int>();
var precursor_fragmentation_methods = new SortedDictionary<int, string>();
var elapsed_scan_times = new SortedDictionary<int, double>();
var ion_injection_times = new SortedDictionary<int, double>();
var precursor_sns = new SortedDictionary<int, double?>();
var precursor_peak_depths = new SortedDictionary<int, int>();
//raw = (IXRawfile2)new XRawfile();
raw = (IXRawfile5)new MSFileReader_XRawfile();
raw.Open(filepath);
raw.SetCurrentController(0, 1);
if (includeLog)
{
log =
new StreamWriter(Path.Combine(LogFolder,
Path.GetFileNameWithoutExtension(filepath) + "_log.txt"));
log.AutoFlush = true;
log.WriteLine("DTA Generator PARAMETERS");
log.WriteLine("Assumed Precursor Charge State Range: " + minimumAssumedPrecursorChargeState + '-' +
maximumAssumedPrecursorChargeState);
log.WriteLine("Clean Precursor: " + cleanPrecursor);
log.WriteLine("Enable ETD Pre-Processing: " + enableEtdPreProcessing);
log.WriteLine("Clean TMT Duplex: " + cleanTmtDuplex);
log.WriteLine("Clean iTRAQ 4-Plex: " + cleanItraq4Plex);
log.WriteLine("Clean TMT 6-Plex: " + cleanTmt6Plex);
log.WriteLine("Clean iTRAQ 8-Plex: " + cleanItraq8Plex);
log.WriteLine();
}
int first_scan_number = -1;
raw.GetFirstSpectrumNumber(ref first_scan_number);
int last_scan_number = -1;
raw.GetLastSpectrumNumber(ref last_scan_number);
int maxCounter = last_scan_number / 1000;
int counter = 0;
// DJB Addition, Check all the scans first to see if they are a precursor scan or not
var msScans = new bool[last_scan_number + 1];
var dta_content_sb = new StringBuilder();
var mgf_content_sb = new StringBuilder();
for (int scanNumber = first_scan_number; scanNumber <= last_scan_number; scanNumber++)
{
int msn = 0;
raw.GetMSOrderForScanNum(scanNumber, ref msn);
if (counter > maxCounter)
{
onUpdateProgress();
counter = 0;
}
counter++;
// skip MS1s
if (msn == 1)
{
msScans[scanNumber] = true;
continue;
}
// Retention Time
double time = -1.0;
raw.RTFromScanNum(scanNumber, ref time);
retention_times.Add(scanNumber, time);
// Precursor m/z
double precursorMZ = double.NaN;
raw.GetPrecursorMassForScanNum(scanNumber, 2, ref precursorMZ);
scan_filter_mzs.Add(scanNumber, precursorMZ);
precursor_mzs.Add(scanNumber, precursorMZ);
double centroid_peak_width = -1.0;
object precursor_labels = null;
object precursor_flags = null;
int mass_list_array_size = -1;
bool no_precursor_scan;
int precursor_scan_number = scanNumber - 1;
no_precursor_scan = true;
for (int i = precursor_scan_number; i >= 0; i--)
{
if (!msScans[i])
continue;
no_precursor_scan = false;
precursor_scan_number = i;
break;
}
string scan_filter = null;
raw.GetFilterForScanNum(scanNumber, ref scan_filter);
if (!no_precursor_scan && includeLog)
{
precursor_labels = null;
precursor_flags = null;
raw.GetLabelData(ref precursor_labels, ref precursor_flags, ref precursor_scan_number);
var precursor_data = (double[,])precursor_labels;
if (precursor_data.Length == 0)
{
centroid_peak_width = -1.0;
precursor_labels = null;
precursor_flags = null;
mass_list_array_size = -1;
raw.GetMassListFromScanNum(ref precursor_scan_number, null, 0, 0, 0, 1,
ref centroid_peak_width, ref precursor_labels, ref precursor_flags,
ref mass_list_array_size);
precursor_data = (double[,])precursor_labels;
}
int? precursor_index = null;
for (int i = precursor_data.GetLowerBound(1); i <= precursor_data.GetUpperBound(1); i++)
{
if (Math.Abs(precursor_data[(int)RawLabelDataColumn.MZ, i] - precursorMZ) <=
PEAK_IDENTIFICATION_MASS_TOLERANCE)
{
if (!precursor_index.HasValue ||
precursor_data[(int)RawLabelDataColumn.Intensity, i] >
precursor_data[(int)RawLabelDataColumn.Intensity, precursor_index.Value])
{
precursor_index = i;
}
}
}
if (!precursor_index.HasValue)
{
for (int i = precursor_data.GetLowerBound(1); i <= precursor_data.GetUpperBound(1); i++)
{
if (!precursor_index.HasValue ||
Math.Abs(precursor_data[(int)RawLabelDataColumn.MZ, i] - precursorMZ) <
Math.Abs(precursor_data[(int)RawLabelDataColumn.MZ, precursor_index.Value] -
precursorMZ))
{
precursor_index = i;
}
}
}
if (precursor_index.HasValue)
{
precursorMZ = precursor_data[(int)RawLabelDataColumn.MZ, precursor_index.Value];
//precursor_mzs.Add(scan_number, precursor_mz);
precursor_intensities.Add(scanNumber,
precursor_data[(int)RawLabelDataColumn.Intensity, precursor_index.Value]);
object precursor_header_labels = null;
object precursor_header_values = null;
int precursor_array_size = -1;
raw.GetTrailerExtraForScanNum(precursor_scan_number, ref precursor_header_labels,
ref precursor_header_values, ref precursor_array_size);
var precursor_header_label_strings = (string[])precursor_header_labels;
var precursor_header_value_strings = (string[])precursor_header_values;
if (precursor_header_label_strings != null && precursor_header_value_strings != null)
{
for (int header_i = precursor_header_label_strings.GetLowerBound(0);
header_i <= precursor_header_label_strings.GetUpperBound(0);
header_i++)
{
if (
precursor_header_label_strings[header_i].StartsWith(
"Ion Injection Time (ms)"))
{
precursor_denormalized_intensities.Add(scanNumber,
precursor_data[(int)RawLabelDataColumn.Intensity, precursor_index.Value
] * double.Parse(precursor_header_value_strings[header_i]) / 1000.0);
}
}
}
if (precursor_data.GetLength(0) > 2)
{
precursor_sns.Add(scanNumber,
(precursor_data[(int)RawLabelDataColumn.Intensity, precursor_index.Value] -
precursor_data[(int)RawLabelDataColumn.NoiseBaseline, precursor_index.Value]) /
precursor_data[(int)RawLabelDataColumn.NoiseLevel, precursor_index.Value]);
}
else
{
precursor_sns.Add(scanNumber, null);
}
int peak_depth = 1;
for (int i = precursor_data.GetLowerBound(1); i <= precursor_data.GetUpperBound(1); i++)
{
if (i != precursor_index.Value)
{
if (precursor_data[(int)RawLabelDataColumn.Intensity, i] >
precursor_data[(int)RawLabelDataColumn.Intensity, precursor_index.Value])
{
peak_depth++;
}
}
}
precursor_peak_depths.Add(scanNumber, peak_depth);
}
}
object header_labels = null;
object header_values = null;
int array_size = -1;
raw.GetTrailerExtraForScanNum(scanNumber, ref header_labels, ref header_values, ref array_size);
var header_label_strings = (string[])header_labels;
var header_value_strings = (string[])header_values;
// Charge State Determination
Polarity polarity = scan_filter.Contains(" - ") ? Polarity.Negative : Polarity.Positive;
object chargeObj = null;
raw.GetTrailerExtraValueForScanNum(scanNumber, "Charge State:", ref chargeObj);
int charge = Convert.ToInt32(chargeObj);
if (charge == 0 || no_precursor_scan)
{
charge = 2; // Default to 2
}
// Flip the sign
charge *= (int)polarity;
//int charge = 0;
//if (header_label_strings != null && header_value_strings != null)
//{
// for (int header_i = header_label_strings.GetLowerBound(0);
// header_i <= header_label_strings.GetUpperBound(0);
// header_i++)
// {
// if (header_label_strings[header_i].StartsWith("Charge"))
// {
// charge = int.Parse(header_value_strings[header_i]);
// if (scan_filter.Contains(" - "))
// {
// charge = -charge;
// }
// precursor_charge_states.Add(scanNumber, charge);
// }
// else if (header_label_strings[header_i].StartsWith("Elapsed Scan Time (sec)"))
// {
// elapsed_scan_times.Add(scanNumber, double.Parse(header_value_strings[header_i]));
// }
// else if (header_label_strings[header_i].StartsWith("Ion Injection Time (ms)"))
// {
// ion_injection_times.Add(scanNumber, double.Parse(header_value_strings[header_i]));
// }
// }
//}
var data = new double[0, 0];
object labels = null;
object flags = null;
try
{
raw.GetLabelData(ref labels, ref flags, ref scanNumber);
data = (double[,])labels;
} catch (Exception) { }
// Check it high res, if not, get the low resolution spectrum
if (data.Length == 0)
{
centroid_peak_width = -1.0;
labels = null;
flags = null;
mass_list_array_size = -1;
raw.GetMassListFromScanNum(ref scanNumber, null, 0, 0, 0, 1, ref centroid_peak_width,
ref labels, ref flags, ref mass_list_array_size);
data = (double[,])labels;
}
if (includeLog)
{
precursor_charge_states.Add(scanNumber, charge);
object elapsedScanTime = null;
raw.GetTrailerExtraValueForScanNum(scanNumber, "Elapsed Scan Time (sec):", ref elapsedScanTime);
elapsed_scan_times.Add(scanNumber, Convert.ToDouble(elapsedScanTime));
object injectionTime = null;
raw.GetTrailerExtraValueForScanNum(scanNumber, "Ion Injection Time (ms):", ref injectionTime);
ion_injection_times.Add(scanNumber, Convert.ToDouble(injectionTime));
double total_ion_current = 0.0;
double base_peak_mz = -1.0;
double base_peak_intensity = -1.0;
for (int data_i = data.GetLowerBound(1); data_i <= data.GetUpperBound(1); data_i++)
{
total_ion_current += data[(int)RawLabelDataColumn.Intensity, data_i];
if (base_peak_mz < 0.0 ||
data[(int)RawLabelDataColumn.Intensity, data_i] > base_peak_intensity)
{
base_peak_mz = data[(int)RawLabelDataColumn.MZ, data_i];
base_peak_intensity = data[(int)RawLabelDataColumn.Intensity, data_i];
}
}
}
string mass_analyzer = scan_filter.Substring(0, 4).ToUpper();
if (!mass_analyzer.Contains("MS"))
{
mass_analyzer = "TQMS";
}
string fragmentation_method = null;
if (groupByFragmentation)
{
foreach (int i in AllIndicesOf(scan_filter, '@'))
{
string temp_scan_filter = scan_filter.Substring(i + 1);
temp_scan_filter = temp_scan_filter.Substring(0, temp_scan_filter.IndexOf(' '));
fragmentation_method += temp_scan_filter.ToUpper() + '-';
}
}
else
{
foreach (int i in AllIndicesOf(scan_filter, '@'))
{
fragmentation_method += scan_filter.Substring(i + 1, 3).ToUpper() + '-';
}
}
fragmentation_method = fragmentation_method.Substring(0, fragmentation_method.Length - 1);
string base_output_filename = Path.GetFileNameWithoutExtension(filepath) + '_' + mass_analyzer +
'_' + fragmentation_method;
if (includeLog)
{
precursor_fragmentation_methods.Add(scanNumber, fragmentation_method);
if (!spectrum_counts.ContainsKey(mass_analyzer))
{
spectrum_counts.Add(mass_analyzer, 0);
}
spectrum_counts[mass_analyzer]++;
if (!dta_counts.ContainsKey(mass_analyzer))
{
dta_counts.Add(mass_analyzer, 0);
}
dta_counts[mass_analyzer] += 1;
if (!spectrum_counts.ContainsKey(fragmentation_method))
{
spectrum_counts.Add(fragmentation_method, 0);
}
spectrum_counts[fragmentation_method]++;
if (!dta_counts.ContainsKey(fragmentation_method))
{
dta_counts.Add(fragmentation_method, 0);
}
dta_counts[fragmentation_method] += 1;
if (!spectrum_counts.ContainsKey(mass_analyzer + ' ' + fragmentation_method))
{
spectrum_counts.Add(mass_analyzer + ' ' + fragmentation_method, 0);
}
spectrum_counts[mass_analyzer + ' ' + fragmentation_method]++;
if (!dta_counts.ContainsKey(mass_analyzer + ' ' + fragmentation_method))
{
dta_counts.Add(mass_analyzer + ' ' + fragmentation_method, 0);
}
dta_counts[mass_analyzer + ' ' + fragmentation_method] += 1;
}
if (sequestDtaOutput || omssaTxtOutput || mascotMgfOutput)
{
Spectrum spectrum = new Spectrum(data);
double retention_time_min = double.NaN;
raw.RTFromScanNum(scanNumber, ref retention_time_min);
double retention_time_s = retention_time_min * 60;
bool isETD = fragmentation_method.StartsWith("ETD") || fragmentation_method.StartsWith("ECD");
string dta_filepath = Path.GetFileNameWithoutExtension(filepath) +
'.' + mass_analyzer + '.' + fragmentation_method +
'.' + scanNumber + '.' +
scanNumber + '.' +
charge + '.' +
"RT_" + retention_time_min.ToString("0.000") + "_min_" +
retention_time_s.ToString("0.0") + "_s" +
".dta";
double precursorMass = Mass.MassFromMz(precursorMZ, charge);
int precursorZ = charge;
// List of mass ranges to exclude
List<IRange<double>> mzRangesToRemove = new List<IRange<double>>(RangesToRemove);
// Precursor cleaning
if (cleanPrecursor || (enableEtdPreProcessing && isETD))
{
CleanPrecursor(mzRangesToRemove, precursorMZ, CleanPrecursorLowMz, CleanPrecursorHighMz);
}
// Neutral Loss cleaning
if (NeutralLossesIncluded)
{
foreach (double mass in neutralLosses)
{
double mz = precursorMZ - Mass.MzFromMass(mass, charge);
double min = mz - LOW_PRECURSOR_CLEANING_WINDOW_MZ;
double max = mz + HIGH_PRECURSOR_CLEANING_WINDOW_MZ;
mzRangesToRemove.Add(new MzRange(min, max));
}
}
// ETD pre-processing
if (enableEtdPreProcessing && isETD)
{
CleanETD(mzRangesToRemove, precursorMass, precursorZ, EtdLowDa, EtdHighDa);
}
//// TMT duplex cleaning
//if (cleanTmtDuplex)
//{
// if (fragmentation_method.StartsWith("CID") || fragmentation_method.StartsWith("PQD") ||
// fragmentation_method.StartsWith("HCD"))
// {
// for (int reduced_charge_i = charge - 1;
// reduced_charge_i >= 1;
// reduced_charge_i--)
// {
// double precursor_tmt_duplex_tag_cleaning_mz = precursorMZ * reduced_charge_i -
// TMT_DUPLEX_CAD_TAG_LOSS_DA /
// reduced_charge_i;
// int p1 = 0;
// while (p1 < peaks.Count)
// {
// double mz = peaks[p1].MZ;
// if ((mz >=
// MINIMUM_TMT_DUPLEX_CAD_REPORTER_MZ -
// TMT_DUPLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// MAXIMUM_TMT_DUPLEX_CAD_REPORTER_MZ +
// TMT_DUPLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >= TMT_DUPLEX_CAD_TAG_MZ - TMT_DUPLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <= TMT_DUPLEX_CAD_TAG_MZ + TMT_DUPLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >=
// precursor_tmt_duplex_tag_cleaning_mz -
// TMT_DUPLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// precursor_tmt_duplex_tag_cleaning_mz +
// TMT_DUPLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ))
// {
// peaks.RemoveAt(p1);
// }
// else
// {
// p1++;
// }
// }
// }
// }
// else if (fragmentation_method.StartsWith("ETD"))
// {
// for (int reduced_charge_i = charge - 1;
// reduced_charge_i >= 1;
// reduced_charge_i--)
// {
// double precursor_tmt_duplex_reporter_loss_cleaning_mz = precursorMZ * charge -
// TMT_DUPLEX_ETD_REPORTER_LOSS_DA /
// reduced_charge_i;
// double precursor_tmt_duplex_tag_loss_cleaning_mz = precursorMZ * charge -
// TMT_DUPLEX_ETD_TAG_LOSS_DA /
// reduced_charge_i;
// int p1 = 0;
// while (p1 < peaks.Count)
// {
// double mz = peaks[p1].MZ;
// if ((mz >=
// MINIMUM_TMT_DUPLEX_ETD_REPORTER_MZ -
// TMT_DUPLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// MAXIMUM_TMT_DUPLEX_ETD_REPORTER_MZ +
// TMT_DUPLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >= TMT_DUPLEX_ETD_TAG_MZ - TMT_DUPLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <= TMT_DUPLEX_ETD_TAG_MZ + TMT_DUPLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >=
// precursor_tmt_duplex_reporter_loss_cleaning_mz -
// TMT_DUPLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// precursor_tmt_duplex_reporter_loss_cleaning_mz +
// TMT_DUPLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >=
// precursor_tmt_duplex_tag_loss_cleaning_mz -
// TMT_DUPLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// precursor_tmt_duplex_tag_loss_cleaning_mz +
// TMT_DUPLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ))
// {
// peaks.RemoveAt(p1);
// }
// else
// {
// p1++;
// }
// }
// }
// }
//}
//// iTRAQ 4-plex cleaning
//if (cleanItraq4Plex)
//{
// if (fragmentation_method.StartsWith("CID") || fragmentation_method.StartsWith("PQD") ||
// fragmentation_method.StartsWith("HCD"))
// {
// double precursor_itraq_4plex_tag_cleaning_mz = precursorMZ * charge -
// ITRAQ_4PLEX_CAD_TAG_LOSS_DA;
// int p1 = 0;
// while (p1 < peaks.Count)
// {
// double mz = peaks[p1].MZ;
// if ((mz >=
// MINIMUM_ITRAQ_4PLEX_CAD_REPORTER_MZ -
// ITRAQ_4PLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// MAXIMUM_ITRAQ_4PLEX_CAD_REPORTER_MZ +
// ITRAQ_4PLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >= ITRAQ_4PLEX_CAD_TAG_MZ - ITRAQ_4PLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <= ITRAQ_4PLEX_CAD_TAG_MZ + ITRAQ_4PLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >=
// precursor_itraq_4plex_tag_cleaning_mz -
// ITRAQ_4PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// precursor_itraq_4plex_tag_cleaning_mz +
// ITRAQ_4PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ))
// {
// peaks.RemoveAt(p1);
// }
// else
// {
// p1++;
// }
// }
// }
// else if (fragmentation_method.StartsWith("ETD"))
// {
// double precursor_itraq_4plex_reporter_loss_cleaning_mz = precursorMZ * charge -
// ITRAQ_4PLEX_ETD_REPORTER_LOSS_DA;
// double precursor_itraq_4plex_tag_loss_cleaning_mz = precursorMZ * charge -
// ITRAQ_4PLEX_ETD_TAG_LOSS_DA;
// int p1 = 0;
// while (p1 < peaks.Count)
// {
// double mz = peaks[p1].MZ;
// if ((mz >=
// MINIMUM_ITRAQ_4PLEX_ETD_REPORTER_MZ -
// ITRAQ_4PLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// MAXIMUM_ITRAQ_4PLEX_ETD_REPORTER_MZ +
// ITRAQ_4PLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >= ITRAQ_4PLEX_ETD_TAG_MZ - ITRAQ_4PLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <= ITRAQ_4PLEX_ETD_TAG_MZ + ITRAQ_4PLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >=
// precursor_itraq_4plex_reporter_loss_cleaning_mz -
// ITRAQ_4PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// precursor_itraq_4plex_reporter_loss_cleaning_mz +
// ITRAQ_4PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >=
// precursor_itraq_4plex_tag_loss_cleaning_mz -
// ITRAQ_4PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// precursor_itraq_4plex_tag_loss_cleaning_mz +
// ITRAQ_4PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ))
// {
// peaks.RemoveAt(p1);
// }
// else
// {
// p1++;
// }
// }
// }
//}
//// TMT 6-plex cleaning
//if (cleanTmt6Plex)
//{
// if (fragmentation_method.StartsWith("CID") || fragmentation_method.StartsWith("PQD") ||
// fragmentation_method.StartsWith("HCD"))
// {
// for (int reduced_charge_i = charge - 1;
// reduced_charge_i >= 1;
// reduced_charge_i--)
// {
// double precursor_tmt_6plex_tag_cleaning_mz = precursorMZ * reduced_charge_i -
// TMT_6PLEX_CAD_TAG_LOSS_DA /
// reduced_charge_i;
// int p1 = 0;
// while (p1 < peaks.Count)
// {
// double mz = peaks[p1].MZ;
// if ((mz >=
// MINIMUM_TMT_6PLEX_CAD_REPORTER_MZ -
// TMT_6PLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// MAXIMUM_TMT_6PLEX_CAD_REPORTER_MZ +
// TMT_6PLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >= TMT_6PLEX_CAD_TAG_MZ - TMT_6PLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <= TMT_6PLEX_CAD_TAG_MZ + TMT_6PLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >=
// precursor_tmt_6plex_tag_cleaning_mz -
// TMT_6PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// precursor_tmt_6plex_tag_cleaning_mz +
// TMT_6PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ))
// {
// peaks.RemoveAt(p1);
// }
// else
// {
// p1++;
// }
// }
// }
// }
// else if (fragmentation_method.StartsWith("ETD"))
// {
// for (int reduced_charge_i = charge - 1;
// reduced_charge_i >= 1;
// reduced_charge_i--)
// {
// double precursor_tmt_6plex_reporter_loss_cleaning_mz = precursorMZ * charge -
// TMT_6PLEX_ETD_REPORTER_LOSS_DA /
// reduced_charge_i;
// double precursor_tmt_6plex_tag_loss_cleaning_mz = precursorMZ * charge -
// TMT_6PLEX_ETD_TAG_LOSS_DA /
// reduced_charge_i;
// int p1 = 0;
// while (p1 < peaks.Count)
// {
// double mz = peaks[p1].MZ;
// if ((mz >=
// MINIMUM_TMT_6PLEX_ETD_REPORTER_MZ -
// TMT_6PLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// MAXIMUM_TMT_6PLEX_ETD_REPORTER_MZ +
// TMT_6PLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >= TMT_6PLEX_ETD_TAG_MZ - TMT_6PLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <= TMT_6PLEX_ETD_TAG_MZ + TMT_6PLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >=
// precursor_tmt_6plex_reporter_loss_cleaning_mz -
// TMT_6PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// precursor_tmt_6plex_reporter_loss_cleaning_mz +
// TMT_6PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >=
// precursor_tmt_6plex_tag_loss_cleaning_mz -
// TMT_6PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// precursor_tmt_6plex_tag_loss_cleaning_mz +
// TMT_6PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ))
// {
// peaks.RemoveAt(p1);
// }
// else
// {
// p1++;
// }
// }
// }
// }
//}
//// iTRAQ 8-plex cleaning
//if (cleanItraq8Plex)
//{
// if (fragmentation_method.StartsWith("CID") || fragmentation_method.StartsWith("PQD") ||
// fragmentation_method.StartsWith("HCD"))
// {
// double precursor_itraq_4plex_tag_cleaning_mz = precursorMZ * charge -
// ITRAQ_8PLEX_CAD_TAG_LOSS_DA;
// int p1 = 0;
// while (p1 < peaks.Count)
// {
// double mz = peaks[p1].MZ;
// if ((mz >=
// MINIMUM_ITRAQ_8PLEX_CAD_REPORTER_MZ -
// ITRAQ_8PLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// MAXIMUM_ITRAQ_8PLEX_CAD_REPORTER_MZ +
// ITRAQ_8PLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >= ITRAQ_8PLEX_CAD_TAG_MZ - ITRAQ_8PLEX_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <= ITRAQ_8PLEX_CAD_TAG_MZ + ITRAQ_8PLEX_CLEANING_MASS_TOLERANCE_MZ)
// ||
// (mz >=
// precursor_itraq_4plex_tag_cleaning_mz -
// ITRAQ_8PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ
// &&
// mz <=
// precursor_itraq_4plex_tag_cleaning_mz +
// ITRAQ_8PLEX_LOSS_CLEANING_MASS_TOLERANCE_MZ))
// {
// peaks.RemoveAt(p1);
// }
// else
// {
// p1++;
// }
// }
// }
//}
// Perform the actual cleaning
var cleanedSpectrum = spectrum.Filter(mzRangesToRemove);
int cleanSpectrumLength = cleanedSpectrum.Count;
double[] mzs = cleanedSpectrum.GetMasses();
double[] intenisties = cleanedSpectrum.GetIntensities();
if (sequestDtaOutput)
{
using (StreamWriter dta = new StreamWriter(Path.Combine(outputFolder, dta_filepath)))
{
if (dta_content_sb.Length > 0)
{
dta.Write(dta_content_sb.ToString());
}
}
}
if (omssaTxtOutput)
{
string txt_filepath = Path.Combine(outputFolder, base_output_filename + ".txt");
StreamWriter writer = null;
if (!txt_outputs.TryGetValue(txt_filepath, out writer))
{
writer = new StreamWriter(new FileStream(txt_filepath, FileMode.Create, FileAccess.Write, FileShare.None, 4096, FileOptions.None));
txt_outputs.Add(txt_filepath, writer);
}
writer.WriteLine("<dta id=\"" + scanNumber + "\" name=\"" + dta_filepath + "\">");
writer.WriteLine();
writer.WriteLine("{0:0.00000} {1:N0}", precursorMass + Constants.Proton, charge);
sb.Clear();
for (int i = 0; i < cleanSpectrumLength; i++)
{
sb.AppendFormat(" {0:F4} {1:F2}", mzs[i], intenisties[i]);
sb.AppendLine();
}
writer.WriteLine(sb.ToString());
writer.WriteLine();
}
if (mascotMgfOutput)
{
string mgf_filepath = Path.Combine(outputFolder,
base_output_filename + ".mgf");
if (!mgf_outputs.ContainsKey(mgf_filepath))
{
mgf_outputs.Add(mgf_filepath, new StreamWriter(mgf_filepath));
}
StreamWriter mgf = mgf_outputs[mgf_filepath];
mgf.WriteLine("BEGIN IONS");
mgf.WriteLine("Title=" + Path.GetFileNameWithoutExtension(dta_filepath));
mgf.WriteLine("SCANS=" + scanNumber);
mgf.WriteLine("RTINSECONDS=" + retention_time_s);
mgf.WriteLine("PEPMASS=" + precursorMZ.ToString("0.00000"));
mgf.WriteLine("CHARGE=" + charge.ToString("0+;0-"));
for (int i = 0; i < cleanSpectrumLength; i++)
{
mgf.WriteLine("{0:0.00000} {1:0.00}", mzs[i], intenisties[i]);
}
mgf.WriteLine("END IONS");
mgf.WriteLine();
}
}
}
if (txt_outputs != null)
{
foreach (StreamWriter sw in txt_outputs.Values)
{
if (sw != null)
{
sw.Close();
}
}
}
if (mgf_outputs != null)
{
foreach (StreamWriter sw in mgf_outputs.Values)
{
if (sw != null)
{
sw.Close();
}
}
}
if (includeLog)
{
log.WriteLine("Spectrum Type\tNumber of Scans");
foreach (var kvp in spectrum_counts)
{
log.WriteLine(kvp.Key + '\t' + kvp.Value);
}
log.WriteLine();
log.WriteLine("Spectrum Type\tNumber of DTAs");
foreach (var kvp in dta_counts)
{
log.WriteLine(kvp.Key + '\t' + kvp.Value);
}
log.WriteLine();
double? min_elapsed = null;
double? max_elapsed = null;
double mean_elapsed = 0.0;
foreach (double elapsed_scan_time in elapsed_scan_times.Values)
{
if (!min_elapsed.HasValue || elapsed_scan_time < min_elapsed)
{
min_elapsed = elapsed_scan_time;
}
if (!max_elapsed.HasValue || elapsed_scan_time > max_elapsed)
{
max_elapsed = elapsed_scan_time;
}
mean_elapsed += elapsed_scan_time;
}
mean_elapsed /= elapsed_scan_times.Count;
if (min_elapsed.HasValue)
{
log.WriteLine("Minimum Fragmentation Elapsed Scan Time (sec): " + min_elapsed.Value);
}
if (max_elapsed.HasValue)
{
log.WriteLine("Maximum Fragmentation Elapsed Scan Time (sec): " + max_elapsed.Value);
}
if (!Double.IsNaN(mean_elapsed))
{
log.WriteLine("Average Fragmentation Elapsed Scan Time (sec): " + mean_elapsed);
}
log.WriteLine();
double? min_injection = null;
double? max_injection = null;
double mean_injection = 0.0;
foreach (double ion_injection_time in ion_injection_times.Values)
{
if (!min_injection.HasValue || ion_injection_time < min_injection)
{
min_injection = ion_injection_time;
}
if (!max_injection.HasValue || ion_injection_time > max_injection)
{
max_injection = ion_injection_time;
}
mean_injection += ion_injection_time;
}
mean_injection /= ion_injection_times.Count;
if (min_injection.HasValue)
{
log.WriteLine("Minimum Fragmentation Ion Injection Time (msec): " + min_injection.Value);
}
if (max_injection.HasValue)
{
log.WriteLine("Maximum Fragmentation Ion Injection Time (msec): " + max_injection.Value);
}
if (!Double.IsNaN(mean_injection))
{
log.WriteLine("Average Fragmentation Ion Injection Time (msec): " + mean_injection);
}
log.WriteLine();
log.WriteLine("Fragmentation Scan Summary");
log.Write("Fragmentation Scan Number\t");
log.Write("Retention Time (min.)\t");
log.Write("Scan Filter m/z\t");
log.Write("Precursor m/z\t");
log.Write("Precursor Intensity\t");
log.Write("Precursor Denormalized Intensity\t");
log.Write("Precursor Charge State\t");
log.Write("Precursor S/N Ratio\t");
log.Write("Precursor Peak Depth\t");
log.Write("Fragmentation Method\t");
log.Write("Elapsed Scan Time (sec)\t");
log.Write("Ion Injection Time (msec)");
log.WriteLine();
foreach (int sn2 in retention_times.Keys)
{
log.Write(sn2.ToString() + '\t');
log.Write(retention_times[sn2].ToString("0.00") + '\t');
log.Write(scan_filter_mzs[sn2].ToString("0.00") + '\t');
log.Write((precursor_mzs.ContainsKey(sn2) ? precursor_mzs[sn2].ToString("0.00000") : "n/a") +
'\t');
log.Write((precursor_intensities.ContainsKey(sn2)
? precursor_intensities[sn2].ToString("0.0")
: "n/a") + '\t');
log.Write((precursor_denormalized_intensities.ContainsKey(sn2)
? precursor_denormalized_intensities[sn2].ToString("0.0")
: "n/a") + '\t');
log.Write((precursor_charge_states.ContainsKey(sn2)
? precursor_charge_states[sn2].ToString()
: "n/a") + '\t');
log.Write((precursor_sns.ContainsKey(sn2) && precursor_sns[sn2].HasValue
? precursor_sns[sn2].Value.ToString()
: "n/a") + '\t');
log.Write((precursor_peak_depths.ContainsKey(sn2)
? precursor_peak_depths[sn2].ToString()
: "n/a") + '\t');
log.Write((precursor_fragmentation_methods.ContainsKey(sn2)
? precursor_fragmentation_methods[sn2]
: "n/a") + '\t');
log.Write((elapsed_scan_times.ContainsKey(sn2) ? elapsed_scan_times[sn2].ToString() : "n/a") +
'\t');
log.Write((ion_injection_times.ContainsKey(sn2) ? ion_injection_times[sn2].ToString() : "n/a") +
'\t');
log.WriteLine();
}
log.Close();
}
if (raw != null)
{
raw.Close();
}
if (log != null && includeLog)
{
log.Close();
}
onFinishedFile(new FilepathEventArgs(filepath));
}
public SpectrumFragmentsMatch(Spectrum spectrum)
{
MassSpectrum = spectrum;
_fragmentSpectralMatches = new HashSet<FragmentSpectralMatch>();
_fragments = new HashSet<Fragment>();
}
public Spectrum(Spectrum spectrum)
: this(spectrum._masses, spectrum._intensities)
{
}
public static byte[] ConvertSpectrumToBytes(Spectrum spectrum, bool zlibCompressed = false)
{
int length = spectrum.Count * sizeof(double);
byte[] bytes = new byte[length * 2];
Buffer.BlockCopy(spectrum._masses, 0, bytes, 0, length);
Buffer.BlockCopy(spectrum._intensities, 0, bytes, length, length);
if (zlibCompressed)
{
bytes = bytes.Compress();
}
return bytes;
}
public static string ConvertSpectrumToBase64String(Spectrum spectrum, bool zlibCompressed = false)
{
byte[] bytes = ConvertSpectrumToBytes(spectrum, zlibCompressed);
return Convert.ToBase64String(bytes);
}
